Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_saves ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
std::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
std::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
std::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
std::optional< tripointlook_around (bool force_3d=false)
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero, bool force_3d=false)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_type gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset (std::function< void(std::string)> out)
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm, bool pump_events=false)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm, bool pump_events=false)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (point p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void toggle_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult, Creature *source)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, point mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, point cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (point delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen = nullptr
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
std::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 768 of file game.h.

768 : int {
769 CHANGE_TAB,
770 QUIT,
771 FIRE, // Who knew, apparently you can do that in list_monsters
772 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 298 of file game.cpp.

298 :
300 scent_ptr( *this ),
303 m( *map_ptr ),
304 u( *u_ptr ),
305 scent( *scent_ptr ),
307 uquit( QUIT_NO ),
308 new_game( false ),
310 mostseen( 0 ),
313 next_npc_id( 1 ),
314 next_mission_id( 1 ),
318 seed( 0 ),
319 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
320{
328 world_generator = std::make_unique<worldfactory>();
329 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
330 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
331}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1022
pimpl< spell_events > spell_events_ptr
Definition: game.h:957
safe_mode_type safe_mode
Definition: game.h:1019
bool safe_mode_warning_logged
Definition: game.h:1033
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:951
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1067
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:977
event_bus & events()
Definition: game.cpp:2712
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:953
character_id next_npc_id
Definition: game.h:1035
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:955
void reset_light_level()
Definition: game.cpp:3556
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:956
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1024
pimpl< map > map_ptr
Definition: game.h:946
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1050
pimpl< live_view > liveview_ptr
Definition: game.h:948
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:954
pimpl< scent_map > scent_ptr
Definition: game.h:950
timed_event_manager & timed_events
Definition: game.h:965
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1062
int next_mission_id
Definition: game.h:1037
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:979
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:958
map & m
Definition: game.h:962
avatar & u
Definition: game.h:963
scent_map & scent
Definition: game.h:964
int user_action_counter
Definition: game.h:1056
live_view & liveview
Definition: game.h:949
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1059
pimpl< avatar > u_ptr
Definition: game.h:947
time_point remoteveh_cache_time
Definition: game.h:1043
static void achievement_attained(const achievement *a)
Definition: game.cpp:291
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:32
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 11814 of file game.cpp.

11815{
11816 //If player is sleeping, get a dream from a carried artifact
11817 //Don't need to check that player is sleeping here, that's done before calling
11818 std::vector<item *> art_items = u.items_with( []( const item & it ) -> bool {
11819 return it.is_artifact();
11820 } );
11821 std::vector<item *> valid_arts;
11822 std::vector<std::vector<std::string>>
11823 valid_dreams; // Tracking separately so we only need to check its req once
11824 //Pull the list of dreams
11825 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
11826 for( auto &it : art_items ) {
11827 //Pick only the ones with an applicable dream
11829 if( art && art->charge_req != ACR_NULL &&
11830 ( it->ammo_remaining() < it->ammo_capacity() ||
11831 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
11832 add_msg( m_debug, "Checking artifact %s", it->tname() );
11833 if( check_art_charge_req( *it ) ) {
11834 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11835 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
11836 add_msg( m_debug, "Adding met dream from %s", it->tname() );
11837 valid_arts.push_back( it );
11838 valid_dreams.push_back( art->dream_msg_met );
11839 }
11840 } else {
11841 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
11842 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
11843 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
11844 valid_arts.push_back( it );
11845 valid_dreams.push_back( art->dream_msg_unmet );
11846 }
11847 }
11848 }
11849 }
11850 if( !valid_dreams.empty() ) {
11851 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
11852 const int selected = rng( 0, valid_arts.size() - 1 );
11853 auto it = valid_arts[selected];
11854 auto msg = random_entry( valid_dreams[selected] );
11855 const std::string &dream = string_format( _( msg ), it->tname() );
11856 add_msg( dream );
11857 } else {
11858 add_msg( m_debug, "Didn't have any dreams, sorry" );
11859 }
11860}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
Definition: item.h:211
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7382
bool is_artifact() const
Definition: item.cpp:6963
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7409
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4554
const itype * type
Definition: item.h:2157
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
@ m_debug
Definition: enums.h:271
bool check_art_charge_req(item &it)
Definition: game.cpp:11517
void add_msg(std::string msg)
Definition: messages.cpp:910
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string_view format, Args &&...args)
Simple wrapper over string_formatter::parse.
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:866
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), item::ammo_capacity(), item::ammo_remaining(), itype::artifact, check_art_charge_req(), item::is_artifact(), visitable< T >::items_with(), m_debug, random_entry(), rng(), string_format(), item::tname(), item::type, u, and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 11636 of file game.cpp.

11637{
11638 int net_str = 0;
11639 int net_dex = 0;
11640 int net_per = 0;
11641 int net_int = 0;
11642 int net_speed = 0;
11643
11644 for( auto &i : effects ) {
11645 switch( i ) {
11646 case AEP_STR_UP:
11647 net_str += 4;
11648 break;
11649 case AEP_DEX_UP:
11650 net_dex += 4;
11651 break;
11652 case AEP_PER_UP:
11653 net_per += 4;
11654 break;
11655 case AEP_INT_UP:
11656 net_int += 4;
11657 break;
11658 case AEP_ALL_UP:
11659 net_str += 2;
11660 net_dex += 2;
11661 net_per += 2;
11662 net_int += 2;
11663 break;
11664 case AEP_STR_DOWN:
11665 net_str -= 3;
11666 break;
11667 case AEP_DEX_DOWN:
11668 net_dex -= 3;
11669 break;
11670 case AEP_PER_DOWN:
11671 net_per -= 3;
11672 break;
11673 case AEP_INT_DOWN:
11674 net_int -= 3;
11675 break;
11676 case AEP_ALL_DOWN:
11677 net_str -= 2;
11678 net_dex -= 2;
11679 net_per -= 2;
11680 net_int -= 2;
11681 break;
11682
11683 case AEP_SPEED_UP:
11684 net_speed += 20;
11685 break;
11686 case AEP_SPEED_DOWN:
11687 net_speed -= 20;
11688 break;
11689
11690 case AEP_PBLUE:
11691 break; // No message
11692
11693 case AEP_SNAKES:
11694 add_msg( m_warning, _( "Your skin feels slithery." ) );
11695 break;
11696
11697 case AEP_INVISIBLE:
11698 add_msg( m_good, _( "You fade into invisibility!" ) );
11699 break;
11700
11701 case AEP_CLAIRVOYANCE:
11703 add_msg( m_good, _( "You can see through walls!" ) );
11704 break;
11705
11707 add_msg( m_good, _( "You can see through everything!" ) );
11708 break;
11709
11710 case AEP_STEALTH:
11711 add_msg( m_good, _( "Your steps stop making noise." ) );
11712 break;
11713
11714 case AEP_GLOW:
11715 add_msg( _( "A glow of light forms around you." ) );
11716 break;
11717
11718 case AEP_PSYSHIELD:
11719 add_msg( m_good, _( "Your mental state feels protected." ) );
11720 break;
11721
11723 add_msg( m_good, _( "You feel insulated." ) );
11724 break;
11725
11726 case AEP_CARRY_MORE:
11727 add_msg( m_good, _( "Your back feels strengthened." ) );
11728 break;
11729
11730 case AEP_FUN:
11731 add_msg( m_good, _( "You feel a pleasant tingle." ) );
11732 break;
11733
11734 case AEP_HUNGER:
11735 add_msg( m_warning, _( "You feel hungry." ) );
11736 break;
11737
11738 case AEP_THIRST:
11739 add_msg( m_warning, _( "You feel thirsty." ) );
11740 break;
11741
11742 case AEP_EVIL:
11743 add_msg( m_warning, _( "You feel an evil presence…" ) );
11744 break;
11745
11746 case AEP_SCHIZO:
11747 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
11748 break;
11749
11750 case AEP_RADIOACTIVE:
11751 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
11752 break;
11753
11754 case AEP_MUTAGENIC:
11755 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
11756 break;
11757
11758 case AEP_ATTENTION:
11759 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
11760 break;
11761
11762 case AEP_FORCE_TELEPORT:
11763 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
11764 break;
11765
11766 case AEP_MOVEMENT_NOISE:
11767 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
11768 break;
11769
11770 case AEP_BAD_WEATHER:
11771 add_msg( m_warning, _( "You feel storms coming." ) );
11772 break;
11773
11774 case AEP_SICK:
11775 add_msg( m_bad, _( "You feel unwell." ) );
11776 break;
11777
11778 case AEP_SMOKE:
11779 add_msg( m_warning, _( "A cloud of smoke appears." ) );
11780 break;
11781 default:
11782 //Suppress warnings
11783 break;
11784 }
11785 }
11786
11787 std::string stat_info;
11788 if( net_str != 0 ) {
11789 stat_info += string_format( _( "Str %s%d! " ),
11790 ( net_str > 0 ? "+" : "" ), net_str );
11791 }
11792 if( net_dex != 0 ) {
11793 stat_info += string_format( _( "Dex %s%d! " ),
11794 ( net_dex > 0 ? "+" : "" ), net_dex );
11795 }
11796 if( net_int != 0 ) {
11797 stat_info += string_format( _( "Int %s%d! " ),
11798 ( net_int > 0 ? "+" : "" ), net_int );
11799 }
11800 if( net_per != 0 ) {
11801 stat_info += string_format( _( "Per %s%d! " ),
11802 ( net_per > 0 ? "+" : "" ), net_per );
11803 }
11804
11805 if( !stat_info.empty() ) {
11806 add_msg( m_neutral, stat_info );
11807 }
11808
11809 if( net_speed != 0 ) {
11810 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
11811 }
11812}
@ m_good
Definition: enums.h:260
@ m_neutral
Definition: enums.h:267
@ m_info
Definition: enums.h:265
@ m_bad
Definition: enums.h:261
@ m_warning
Definition: enums.h:264
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3007 of file game.cpp.

3008{
3009 draw_callbacks.erase(
3010 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3011 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3012 return cbw.expired();
3013 } ),
3014 draw_callbacks.end()
3015 );
3016 draw_callbacks.emplace_back( cb );
3017 cb->added = true;
3019}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:2972
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:225
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1879 of file game.cpp.

1880{
1881 follower_ids.insert( id );
1882 u.follower_ids.insert( id );
1883}
std::set< character_id > follower_ids
Definition: game.h:1038
std::set< character_id > follower_ids
Definition: player.h:261

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 11972 of file game.cpp.

11973{
11974 return Creature_range( *this );
11975}
friend class Creature_range
Definition: game.h:334

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 11977 of file game.cpp.

11978{
11979 return monster_range( *this );
11980}
friend class monster_range
Definition: game.h:333

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 11982 of file game.cpp.

11983{
11984 return npc_range( *this );
11985}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 11886 of file game.cpp.

11887{
11888 return get_npcs_if( [&]( const npc & guy ) {
11889 if( !guy.is_hallucination() ) {
11890 return guy.is_ally( g->u );
11891 } else {
11892 return false;
11893 }
11894 } );
11895}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:11909
Definition: npc.h:744
bool is_hallucination() const override
Definition: npc.cpp:3285

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1867 of file game.cpp.

1868{
1869 int ret = next_mission_id;
1871 return ret;
1872}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3564 of file game.cpp.

3565{
3567 ++next_npc_id;
3568 return ret;
3569}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1666 of file game.cpp.

1667{
1668 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1669 vehicle *&v = veh.v;
1670 if( v->is_following ) {
1671 v->drive_to_local_target( m.getabs( u.pos() ), true );
1672 } else if( v->is_patrolling ) {
1673 v->autopilot_patrol();
1674 }
1675 }
1676}
const tripoint & pos() const override
Definition: character.cpp:591
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8367
VehicleList get_vehicles()
Definition: map.cpp:296
A vehicle as a whole with all its components.
Definition: vehicle.h:676
void autopilot_patrol()
Definition: vehicle.cpp:702
bool is_following
Definition: vehicle.h:2008
bool is_patrolling
Definition: vehicle.h:2009
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:817

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11303 of file game.cpp.

11304{
11305 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11306 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11307 return;
11308 }
11309 quicksave(); //Driving checks are handled by quicksave()
11310}
time_t last_save_timestamp
Definition: game.h:1040
void quicksave()
Definition: game.cpp:11258
@ time
Recharges slowly with time.

References last_save_timestamp, quicksave(), and time.

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8300 of file game.cpp.

8301{
8302 static const std::string salvage_string = "salvage";
8303 if( u.controlling_vehicle ) {
8304 add_msg( m_info, _( "You can't butcher while driving!" ) );
8305 return;
8306 }
8307
8308 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8309 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8310 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8311 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8312
8313 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8314 if( m.has_flag( "SEALED", u.pos() ) ) {
8315 if( m.sees_some_items( u.pos(), u ) ) {
8316 add_msg( m_info, _( "You can't access the items here." ) );
8317 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8318 add_msg( m_info, no_corpse_msg );
8319 } else {
8320 add_msg( m_info, no_knife_msg );
8321 }
8322 return;
8323 }
8324
8325 const item *first_item_without_tools = nullptr;
8326 // Indices of relevant items
8327 std::vector<map_stack::iterator> corpses;
8328 std::vector<map_stack::iterator> disassembles;
8329 std::vector<map_stack::iterator> salvageables;
8330 map_stack items = m.i_at( u.pos() );
8331 const inventory &crafting_inv = u.crafting_inventory();
8332
8333 // TODO: Properly handle different material whitelists
8334 // TODO: Improve quality of this section
8335 auto salvage_filter = []( item it ) {
8336 const auto usable = it.get_usable_item( salvage_string );
8337 return usable != nullptr;
8338 };
8339
8340 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8341 int salvage_tool_index = INT_MIN;
8342 item *salvage_tool = nullptr;
8343 const salvage_actor *salvage_iuse = nullptr;
8344 if( !salvage_tools.empty() ) {
8345 salvage_tool = salvage_tools.front();
8346 salvage_tool_index = u.get_item_position( salvage_tool );
8347 item *usable = salvage_tool->get_usable_item( salvage_string );
8348 salvage_iuse = dynamic_cast<const salvage_actor *>(
8349 usable->get_use( salvage_string )->get_actor_ptr() );
8350 }
8351
8352 // Reserve capacity for each to hold entire item set if necessary to prevent
8353 // reallocations later on
8354 corpses.reserve( items.size() );
8355 salvageables.reserve( items.size() );
8356 disassembles.reserve( items.size() );
8357
8358 // Split into corpses, disassemble-able, and salvageable items
8359 // It's not much additional work to just generate a corpse list and
8360 // clear it later, but does make the splitting process nicer.
8361 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8362 if( it->is_corpse() ) {
8363 corpses.push_back( it );
8364 } else {
8365 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8366 salvageables.push_back( it );
8367 }
8368 if( crafting::can_disassemble( u, *it, crafting_inv ).success() ) {
8369 disassembles.push_back( it );
8370 } else if( !first_item_without_tools ) {
8371 first_item_without_tools = &*it;
8372 }
8373 }
8374 }
8375
8376 // Clear corpses if butcher and dissect factors are INT_MIN
8377 if( factor == INT_MIN && factorD == INT_MIN ) {
8378 corpses.clear();
8379 }
8380
8381 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8382 if( factor > INT_MIN || factorD > INT_MIN ) {
8383 add_msg( m_info, no_corpse_msg );
8384 } else {
8385 add_msg( m_info, no_knife_msg );
8386 }
8387
8388 if( first_item_without_tools ) {
8389 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8390 // Just for the "You need x to disassemble y" messages
8391 const auto ret = crafting::can_disassemble( u, *first_item_without_tools, crafting_inv );
8392 if( !ret.success() ) {
8393 add_msg( m_info, "%s", ret.c_str() );
8394 }
8395 }
8396 return;
8397 }
8398
8399 Creature *hostile_critter = is_hostile_very_close();
8400 if( hostile_critter != nullptr ) {
8401 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8402 hostile_critter->disp_name() ) ) {
8403 return;
8404 }
8405 }
8406
8407 // Magic indices for special butcher options
8408 enum : int {
8409 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8410 MULTIBUTCHER,
8411 MULTIDISASSEMBLE_ONE,
8412 MULTIDISASSEMBLE_ALL,
8413 NUM_BUTCHER_ACTIONS
8414 };
8415 // What are we butchering (i.e.. which vector to pick indices from)
8416 enum {
8417 BUTCHER_CORPSE,
8418 BUTCHER_DISASSEMBLE,
8419 BUTCHER_SALVAGE,
8420 BUTCHER_OTHER // For multisalvage etc.
8421 } butcher_select = BUTCHER_CORPSE;
8422 // Index to std::vector of iterators...
8423 int indexer_index = 0;
8424
8425 // Generate the indexed stacks so we can display them nicely
8426 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8427 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8428 // Always ask before cutting up/disassembly, but not before butchery
8429 size_t ret = 0;
8430 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8431 uilist kmenu;
8432 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8433
8434 size_t i = 0;
8435 // Add corpses, disassembleables, and salvagables to the UI
8436 add_corpses( kmenu, corpses, i );
8437 add_disassemblables( kmenu, disassembly_stacks, i );
8438 if( salvage_iuse && !salvageables.empty() ) {
8439 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8440 }
8441
8442 if( corpses.size() > 1 ) {
8443 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8444 }
8445 if( disassembles.size() > 1 ) {
8446 int time_to_disassemble = 0;
8447 int time_to_disassemble_all = 0;
8448 for( const auto &stack : disassembly_stacks ) {
8449 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8450 time_to_disassemble += time;
8451 time_to_disassemble_all += time * stack.second;
8452 }
8453
8454 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8455 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8456 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8457 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8458 }
8459 if( salvage_iuse && salvageables.size() > 1 ) {
8460 int time_to_salvage = 0;
8461 for( const auto &stack : salvage_stacks ) {
8462 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8463 }
8464
8465 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8466 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8467 }
8468
8469 kmenu.query();
8470
8471 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8472 return;
8473 }
8474
8475 ret = static_cast<size_t>( kmenu.ret );
8476 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8477 butcher_select = BUTCHER_OTHER;
8478 indexer_index = ret;
8479 } else if( ret < corpses.size() ) {
8480 butcher_select = BUTCHER_CORPSE;
8481 indexer_index = ret;
8482 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8483 butcher_select = BUTCHER_DISASSEMBLE;
8484 indexer_index = ret - corpses.size();
8485 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8486 butcher_select = BUTCHER_SALVAGE;
8487 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8488 } else {
8489 debugmsg( "Invalid butchery index: %d", ret );
8490 return;
8491 }
8492 }
8493
8494 if( !u.has_morale_to_craft() ) {
8495 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8496 add_msg( m_info,
8497 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8498 } else {
8499 add_msg( m_info,
8500 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8501 }
8502 return;
8503 }
8504 const auto helpers = character_funcs::get_crafting_helpers( u );
8505 for( const npc *np : helpers ) {
8506 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8507 }
8508 switch( butcher_select ) {
8509 case BUTCHER_OTHER:
8510 switch( indexer_index ) {
8511 case MULTISALVAGE:
8512 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8513 break;
8514 case MULTIBUTCHER:
8515 butcher_submenu( corpses );
8516 for( map_stack::iterator &it : corpses ) {
8517 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8518 }
8519 break;
8520 case MULTIDISASSEMBLE_ONE:
8521 crafting::disassemble_all( u, false );
8522 break;
8523 case MULTIDISASSEMBLE_ALL:
8525 break;
8526 default:
8527 debugmsg( "Invalid butchery type: %d", indexer_index );
8528 return;
8529 }
8530 break;
8531 case BUTCHER_CORPSE: {
8532 butcher_submenu( corpses, indexer_index );
8533 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8534 }
8535 break;
8536 case BUTCHER_DISASSEMBLE: {
8537 // Pick index of first item in the disassembly stack
8538 item *const target = &*disassembly_stacks[indexer_index].first;
8540 }
8541 break;
8542 case BUTCHER_SALVAGE: {
8543 if( !salvage_iuse || !salvage_tool ) {
8544 debugmsg( "null salve_iuse or salvage_tool" );
8545 } else {
8546 // Pick index of first item in the salvage stack
8547 item *const target = &*salvage_stacks[indexer_index].first;
8548 item_location item_loc( map_cursor( u.pos() ), target );
8549 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8550 }
8551 }
8552 break;
8553 }
8554}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:253
player_activity activity
Definition: character.h:1550
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2339
bool has_morale_to_craft() const
Definition: crafting.cpp:336
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:554
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9161
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3578
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7969
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7943
Definition: map.h:105
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2369
map_stack i_at(const tripoint &p)
Definition: map.cpp:4182
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4828
std::vector< item_location > targets
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:61
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:962
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:942
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8150
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8108
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8129
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8061
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8096
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:838
std::vector< npc * > get_crafting_helpers(const Character &who, int max)
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
ret_val< bool > can_disassemble(const Character &who, const item &obj, const inventory &inv)
Check if character can disassemble an item using the given crafting inventory.
Definition: crafting.cpp:1877
bool disassemble(avatar &you)
Prompt for an item to disassemble, then start activity.
Definition: crafting.cpp:2061
bool disassemble_all(avatar &you, bool recursively)
Start an activity to disassemble all items in avatar's square.
Definition: crafting.cpp:2072
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:315
string_id< quality > quality_id
Definition: type_id.h:184

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), crafting::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, crafting::disassemble(), crafting::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), character_funcs::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1246 of file game.cpp.

1247{
1248 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1250 return;
1251 }
1252 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1253 const int light_sight_range = u.sight_range( g_light_level );
1254 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1255
1256 // The maximal offset will leave at least this many tiles
1257 // between the PC and the edge of the main window.
1258 static const int border_range = 2;
1259 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1260 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1261
1262 // velocity at or below this results in no offset at all
1263 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1264 // velocity at or above this results in maximal offset
1265 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1267 float velocity = veh->velocity;
1268 rl_vec2d offset = veh->move_vec();
1269 if( !veh->skidding && veh->player_in_control( u ) &&
1270 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1271 // Use the cruise controlled velocity, but only if
1272 // it is not too different from the actual velocity.
1273 // The actual velocity changes too often (see above slowdown).
1274 // Using it makes would make the offset change far too often.
1275 offset = veh->face_vec();
1276 velocity = veh->cruise_velocity;
1277 }
1278 float rel_offset;
1279 if( std::fabs( velocity ) < min_offset_vel ) {
1280 rel_offset = 0;
1281 } else if( std::fabs( velocity ) > max_offset_vel ) {
1282 rel_offset = ( velocity > 0 ) ? 1 : -1;
1283 } else {
1284 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1285 }
1286 // Squeeze into the corners, by making the offset vector longer,
1287 // the PC is still in view as long as both offset.x and
1288 // offset.y are <= 1
1289 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1290 offset.y /= std::fabs( offset.x );
1291 offset.x = ( offset.x > 0 ) ? +1 : -1;
1292 } else if( std::fabs( offset.y ) > 0.2 ) {
1293 offset.x /= std::fabs( offset.y );
1294 offset.y = offset.y > 0 ? +1 : -1;
1295 }
1296 offset.x *= rel_offset;
1297 offset.y *= rel_offset;
1298 offset.x *= max_offset.x;
1299 offset.y *= max_offset.y;
1300 // [ ----@---- ] sight=6
1301 // [ --@------ ] offset=2
1302 // [ -@------# ] offset=3
1303 // can see sights square in every direction, total visible area is
1304 // (2*sight+1)x(2*sight+1), but the window is only
1305 // getmaxx(w_terrain) x getmaxy(w_terrain)
1306 // The area outside of the window is maxoff (sight-getmax/2).
1307 // If that value is <= 0, the whole visible area fits the window.
1308 // don't apply the view offset at all.
1309 // If the offset is > maxoff, only apply at most maxoff, everything
1310 // above leads to invisible area in front of the car.
1311 // It will display (getmax/2+offset) squares in one direction and
1312 // (getmax/2-offset) in the opposite direction (centered on the PC).
1313 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1314 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1315 if( maxoff.x <= 0 ) {
1316 offset.x = 0;
1317 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1318 offset.x = maxoff.x;
1319 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1320 offset.x = -maxoff.x;
1321 }
1322 if( maxoff.y <= 0 ) {
1323 offset.y = 0;
1324 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1325 offset.y = maxoff.y;
1326 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1327 offset.y = -maxoff.y;
1328 }
1329
1330 // Turn the offset into a vector that increments the offset toward the desired position
1331 // instead of setting it there instantly, should smooth out jerkiness.
1332 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1333
1334 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1335 ( offset_difference.y < 0 ) ? -1 : 1 );
1336 // Shift the current offset in the direction of the calculated offset by one tile
1337 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1338 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1339 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1340 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1341 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1342
1343 set_driving_view_offset( point( offset.x, offset.y ) );
1344}
int posz() const override
Definition: character.h:799
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:596
point driving_view_offset
Definition: game.h:996
catacurses::window w_terrain
Definition: game.h:986
void set_driving_view_offset(point p)
Definition: game.cpp:1603
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3550
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:2024
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:278
int velocity
Definition: vehicle.h:1943
int cruise_velocity
Definition: vehicle.h:1945
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1228
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:69
static constexpr point point_zero
Definition: point.h:260
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1705 of file game.cpp.

1706{
1709 return false;
1710 }
1711 if( u.has_distant_destination() ) {
1712 if( cancel_auto_move( u, text ) ) {
1713 return true;
1714 } else {
1716 return false;
1717 }
1718 }
1719 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1720 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1722
1723 const auto &action = query_popup()
1724 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1725 .message( force_uc ?
1726 pgettext( "cancel_activity_or_ignore_query",
1727 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1728 pgettext( "cancel_activity_or_ignore_query",
1729 "<color_light_red>%s %s</color>" ),
1730 text, u.activity.get_stop_phrase() )
1731 .option( "YES", allow_key )
1732 .option( "NO", allow_key )
1733 .option( "MANAGER", allow_key )
1734 .option( "IGNORE", allow_key )
1735 .query()
1736 .action;
1737
1738 if( action == "YES" ) {
1740 return true;
1741 }
1742 if( action == "IGNORE" ) {
1744 for( auto &activity : u.backlog ) {
1745 activity.ignore_distraction( type );
1746 }
1747 }
1748 if( action == "MANAGER" ) {
1751 return true;
1752 }
1753
1756
1757 return false;
1758}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9204
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1551
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
distraction_manager::distraction_manager_gui & get_distraction_manager()
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1692
void redraw()
Invalidate the top window and redraw all invalidated windows.
Definition: ui_manager.cpp:389
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), get_distraction_manager(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), distraction_manager::distraction_manager_gui::show(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1760 of file game.cpp.

1761{
1763 if( u.has_distant_destination() ) {
1764 if( cancel_auto_move( u, text ) ) {
1765 return true;
1766 } else {
1768 return false;
1769 }
1770 }
1771 if( !u.activity ) {
1772 return false;
1773 }
1774 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1778 return true;
1779 }
1780 return false;
1781}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9236

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1678 of file game.cpp.

1680{
1681 //spawn the corpse, rotten by a part of the duration
1683 catch_duration ) ) );
1684 if( u.sees( pos ) ) {
1685 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1686 }
1687 //quietly kill the caught
1688 fish->no_corpse_quiet = true;
1689 fish->die( p );
1690}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:507
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4327
bool no_corpse_quiet
Definition: monster.h:481
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2276
const mtype * type
Definition: monster.h:477
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:380
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 395 of file npctalk.cpp.

396{
397 int volume = u.get_shout_volume();
398
399 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
400 // TODO: Get rid of the z-level check when z-level vision gets "better"
401 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
402 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
403 } );
404 const int available_count = available.size();
405 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
406 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
407 } );
408 const int follower_count = followers.size();
409 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
410 return guy.mission == NPC_MISSION_GUARD_ALLY &&
411 guy.companion_mission_role_id != "FACTION_CAMP" &&
412 guy.can_hear( u.pos(), volume );
413 } );
414 const int guard_count = guards.size();
415
416 if( u.has_trait( trait_PROF_FOODP ) && !( u.is_wearing( itype_id( "foodperson_mask" ) ) ||
417 u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
418 u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
419 return;
420 }
421 std::vector<vehicle *> animal_vehicles;
422 std::vector<vehicle *> following_vehicles;
423 std::vector<vehicle *> magic_vehicles;
424 std::vector<vehicle *> magic_following_vehicles;
425 for( auto &veh : m.get_vehicles() ) {
426 auto &v = veh.v;
427 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( u ) ) {
428 animal_vehicles.push_back( v );
429 if( v->is_following ) {
430 following_vehicles.push_back( v );
431 }
432 }
433 if( v->magic ) {
434 for( const vpart_reference &vp : v->get_all_parts() ) {
435 const vpart_info &vpi = vp.info();
436 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
437 magic_vehicles.push_back( v );
438 if( v->is_following ) {
439 magic_following_vehicles.push_back( v );
440 }
441 break;
442 }
443 }
444 }
445 }
446
447 uilist nmenu;
448 nmenu.text = std::string( _( "What do you want to do?" ) );
449
450 if( !available.empty() ) {
451 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
452 string_format( _( "Talk to %s" ), available.front()->name ) :
453 _( "Talk to…" )
454 );
455 }
456 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
457 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
458 if( !animal_vehicles.empty() ) {
460 _( "Whistle at your animals pulling vehicles to follow you." ) );
461 }
462 if( !magic_vehicles.empty() ) {
464 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
465 }
466 if( !magic_following_vehicles.empty() ) {
468 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
469 }
470 if( !following_vehicles.empty() ) {
472 _( "Whistle at your animals pulling vehicles to stop following you." ) );
473 }
474 if( !guards.empty() ) {
475 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
476 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
477 _( "Tell someone to follow…" )
478 );
479 }
480 if( !followers.empty() ) {
481 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
482 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
483 _( "Tell someone to guard…" )
484 );
485 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
486 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
487 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
488 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
489 _( "Tell everyone on your team to prepare for danger" ) );
490 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
491 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
492 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
493 }
494 std::string message;
495 std::string yell_msg;
496 bool is_order = true;
497 nmenu.query();
498
499 if( nmenu.ret < 0 ) {
500 return;
501 }
502
503 switch( nmenu.ret ) {
504 case NPC_CHAT_TALK: {
505 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
506 if( npcselect < 0 ) {
507 return;
508 }
509 available[npcselect]->talk_to_u();
510 break;
511 }
512 case NPC_CHAT_YELL:
513 is_order = false;
514 message = _( "loudly." );
515 break;
516 case NPC_CHAT_SENTENCE: {
517 std::string popupdesc = _( "Enter a sentence to yell" );
519 popup.title( _( "Yell a sentence" ) )
520 .width( 64 )
521 .description( popupdesc )
522 .identifier( "sentence" )
523 .max_length( 128 )
524 .query();
525 yell_msg = popup.text();
526 is_order = false;
527 break;
528 }
529 case NPC_CHAT_GUARD: {
530 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
531 if( npcselect < 0 ) {
532 return;
533 }
534 if( npcselect == follower_count ) {
535 for( npc *them : followers ) {
537 }
538 yell_msg = _( "Everyone guard here!" );
539 } else {
540 talk_function::assign_guard( *followers[npcselect] );
541 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
542 }
543 break;
544 }
545 case NPC_CHAT_FOLLOW: {
546 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
547 if( npcselect < 0 ) {
548 return;
549 }
550 if( npcselect == guard_count ) {
551 for( npc *them : guards ) {
553 }
554 yell_msg = _( "Everyone follow me!" );
555 } else {
556 talk_function::stop_guard( *guards[npcselect] );
557 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
558 }
559 break;
560 }
561 case NPC_CHAT_AWAKE:
562 for( npc *them : followers ) {
563 talk_function::wake_up( *them );
564 }
565 yell_msg = _( "Stay awake!" );
566 break;
567 case NPC_CHAT_MOUNT:
568 for( npc *them : followers ) {
569 if( them->has_effect( effect_riding ) ) {
570 continue;
571 }
573 }
574 yell_msg = _( "Mount up!" );
575 break;
577 for( npc *them : followers ) {
578 if( them->has_effect( effect_riding ) ) {
579 them->npc_dismount();
580 }
581 }
582 yell_msg = _( "Dismount!" );
583 break;
584 case NPC_CHAT_DANGER:
585 for( npc *them : followers ) {
586 them->rules.set_danger_overrides();
587 }
588 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
589 "and don't open any doors." );
590 break;
592 for( npc *p : followers ) {
594 }
595 yell_msg = _( "As you were." );
596 break;
597 case NPC_CHAT_ORDERS:
598 npc_temp_orders_menu( followers );
599 break;
602 break;
605 break;
608 break;
611 break;
612 default:
613 return;
614 }
615
616 if( !yell_msg.empty() ) {
617 message = string_format( "\"%s\"", yell_msg );
618 }
619 if( !message.empty() ) {
620 add_msg( _( "You yell %s" ), message );
621 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
622 }
623
624 u.moves -= 100;
625}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:570
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7605
bool can_hear(const tripoint &source, int volume) const
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3215
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:101
int get_shout_volume() const
Definition: character.cpp:7562
int moves
Definition: creature.h:578
std::string companion_mission_role_id
Definition: npc.h:1279
npc_mission mission
Definition: npc.h:1286
bool is_player_ally() const
Definition: npc.cpp:2003
bool is_following() const
Definition: npc.cpp:2034
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:411
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4127
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:150
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:221
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:378
static void tell_veh_stop_following()
Definition: npctalk.cpp:341
static void assign_veh_to_follow()
Definition: npctalk.cpp:352
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:253
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:201
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:215
@ NPC_CHAT_YELL
Definition: npctalk.cpp:196
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:199
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:198
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:202
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:212
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:204
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:197
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:211
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:203
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:200
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:213
@ NPC_CHAT_TALK
Definition: npctalk.cpp:195
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:214
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:362
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), player::add_msg_if_player(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, get_npcs_if(), Character::get_shout_volume(), map::get_vehicles(), vpart_info::has_flag(), Character::has_trait(), npc::is_following(), npc::is_player_ally(), Character::is_wearing(), m, m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6017 of file game.cpp.

6018{
6019 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6020}
static zone_manager & get_manager()
Definition: clzones.cpp:126
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 8556 of file game.cpp.

8557{
8558 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
8559 // Already warned player since safe_mode_warning_logged is set.
8560 return false;
8561 }
8562
8563 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
8564 if( !msg_ignore.empty() ) {
8565 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
8566 // Operate on a wide-char basis to prevent corrupted multi-byte string
8567 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
8568 msg_ignore = wstr_to_utf8( msg_ignore_wide );
8569 }
8570
8572 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
8573 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
8575 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
8576 } else {
8578 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
8579 }
8581 return false;
8582 }
8583 if( safe_mode != SAFE_MODE_STOP ) {
8584 return true;
8585 }
8586 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
8587 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
8588 return true;
8589 }
8590 // Monsters around and we don't want to run
8591 std::string spotted_creature_name;
8592 const monster_visible_info &mon_visible = u.get_mon_visible();
8593 const auto &new_seen_mon = mon_visible.new_seen_mon;
8594
8595 if( new_seen_mon.empty() ) {
8596 // naming consistent with code in game::mon_info
8597 spotted_creature_name = _( "a survivor" );
8599 } else {
8600 spotted_creature_name = new_seen_mon.back()->name();
8601 get_safemode().lastmon_whitelist = spotted_creature_name;
8602 }
8603
8604 std::string whitelist;
8605 if( !get_safemode().empty() ) {
8606 whitelist = string_format( _( " or %s to whitelist the monster" ),
8608 }
8609
8610 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
8612 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
8613 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
8615 return false;
8616}
std::string press_x(action_id act)
Definition: action.cpp:457
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:217
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:219
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:211
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1186
int get_int_base() const override
Definition: avatar.cpp:1022
monster_visible_info & get_mon_visible()
Definition: avatar.h:226
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:288
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:293
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:41

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6012 of file game.cpp.

6013{
6014 return zone_manager::get_manager().has( type, m.getabs( where ) );
6015}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 942 of file game.cpp.

943{
944 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
945 // Put (non-hallucinations) into the overmap so they are not lost.
946 for( monster &critter : all_monsters() ) {
947 despawn_monster( critter );
948 }
949 // Reset NPC factions and disposition
951 // Save the factions', missions and set the NPC's overmap coordinates
952 // Npcs are saved in the overmap.
953 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
954 // save artifacts.
956
957 // and the overmap, and the local map.
958 save_maps(); //Omap also contains the npcs who need to be saved.
959 }
960
961 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
962 std::vector<std::string> vRip;
963
964 int iMaxWidth = 0;
965 int iNameLine = 0;
966 int iInfoLine = 0;
967
970 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
971 vRip.emplace_back( " _______ ___" );
972 vRip.emplace_back( " < `/ |" );
973 vRip.emplace_back( " > _ _ (" );
974 vRip.emplace_back( " | |_) | |_) |" );
975 vRip.emplace_back( " | | \\ | | |" );
976 vRip.emplace_back( " ______.__%_| |_________ __" );
977 vRip.emplace_back( " _/ \\| |" );
978 iNameLine = vRip.size();
979 vRip.emplace_back( "| <" );
980 vRip.emplace_back( "| |" );
981 iMaxWidth = utf8_width( vRip.back() );
982 vRip.emplace_back( "| |" );
983 vRip.emplace_back( "|_____.-._____ __/|_________|" );
984 vRip.emplace_back( " | |" );
985 iInfoLine = vRip.size();
986 vRip.emplace_back( " | |" );
987 vRip.emplace_back( " | <" );
988 vRip.emplace_back( " | |" );
989 vRip.emplace_back( " | _ |" );
990 vRip.emplace_back( " |__/ |" );
991 vRip.emplace_back( " % / `--. |%" );
992 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
993 vRip.emplace_back( " `\\%`@| |@@%@%%" );
994 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
995 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
996
997 } else {
998 vRip.emplace_back( " _______ ___" );
999 vRip.emplace_back( " | \\/ |" );
1000 vRip.emplace_back( " | |" );
1001 vRip.emplace_back( " | |" );
1002 iInfoLine = vRip.size();
1003 vRip.emplace_back( " | |" );
1004 vRip.emplace_back( " | |" );
1005 vRip.emplace_back( " | |" );
1006 vRip.emplace_back( " | |" );
1007 vRip.emplace_back( " | <" );
1008 vRip.emplace_back( " | _ |" );
1009 vRip.emplace_back( " |__/ |" );
1010 vRip.emplace_back( " ______.__%_| |__________ _" );
1011 vRip.emplace_back( " _/ \\| \\" );
1012 iNameLine = vRip.size();
1013 vRip.emplace_back( "| <" );
1014 vRip.emplace_back( "| |" );
1015 iMaxWidth = utf8_width( vRip.back() );
1016 vRip.emplace_back( "| |" );
1017 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1018 vRip.emplace_back( " % / `_-. _ |%" );
1019 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1020 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1021 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1022 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1023 }
1024 } else {
1025 vRip.emplace_back( R"( _________ ____ )" );
1026 vRip.emplace_back( R"( _/ `/ \_ )" );
1027 vRip.emplace_back( R"( _/ _ _ \_. )" );
1028 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1029 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1030 vRip.emplace_back( R"( _/ \_ )" );
1031 vRip.emplace_back( R"(| |)" );
1032 iNameLine = vRip.size();
1033 vRip.emplace_back( R"( ) < )" );
1034 vRip.emplace_back( R"(| |)" );
1035 vRip.emplace_back( R"(| |)" );
1036 vRip.emplace_back( R"(| _ |)" );
1037 vRip.emplace_back( R"(|__/ |)" );
1038 iMaxWidth = utf8_width( vRip.back() );
1039 vRip.emplace_back( R"( / `--. |)" );
1040 vRip.emplace_back( R"(| ( )" );
1041 iInfoLine = vRip.size();
1042 vRip.emplace_back( R"(| |)" );
1043 vRip.emplace_back( R"(| |)" );
1044 vRip.emplace_back( R"(| % . |)" );
1045 vRip.emplace_back( R"(| @` %% |)" );
1046 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1047 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1048 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1049 }
1050
1051 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1052 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1053
1055 point( iOffsetX, iOffsetY ) );
1056 draw_border( w_rip );
1057
1058 sfx::do_player_death_hurt( g->u, true );
1063
1064 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1065 size_t iX = 0;
1066 const char *str = vRip[iY].data();
1067 for( int slen = vRip[iY].size(); slen > 0; ) {
1068 const uint32_t cTemp = UTF8_getch( &str, &slen );
1069 if( cTemp != U' ' ) {
1070 nc_color ncColor = c_light_gray;
1071
1072 if( cTemp == U'%' ) {
1073 ncColor = c_green;
1074
1075 } else if( cTemp == U'_' || cTemp == U'|' ) {
1076 ncColor = c_white;
1077
1078 } else if( cTemp == U'@' ) {
1079 ncColor = c_brown;
1080
1081 } else if( cTemp == U'*' ) {
1082 ncColor = c_red;
1083 }
1084
1085 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1086 cTemp );
1087 }
1088 iX += mk_wcwidth( cTemp );
1089 }
1090 }
1091
1092 std::string sTemp;
1093
1094 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1095
1097 const int minutes = to_minutes<int>( survived ) % 60;
1098 const int hours = to_hours<int>( survived ) % 24;
1099 const int days = to_days<int>( survived );
1100
1101 if( days > 0 ) {
1102 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1103 } else if( hours > 0 ) {
1104 sTemp = string_format( "%dh %dm", hours, minutes );
1105 } else {
1106 sTemp = string_format( "%dm", minutes );
1107 }
1108
1109 center_print( w_rip, iInfoLine++, c_white, sTemp );
1110
1111 const int iTotalKills = get_kill_tracker().monster_kill_count();
1112
1113 sTemp = _( "Kills:" );
1114 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1115 ( sTemp + " " ) );
1116 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1117
1118 sTemp = _( "In memory of:" );
1119 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1121 sTemp );
1122
1123 sTemp = u.name;
1124 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1125 sTemp );
1126
1127 sTemp = _( "Last Words:" );
1128 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1130 sTemp );
1131
1132 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1133 std::string sLastWords = string_input_popup()
1134 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1135 .max_length( iMaxWidth - 4 - 1 )
1136 .query_string();
1137 death_screen();
1138 const bool is_suicide = uquit == QUIT_SUICIDE;
1139 events().send<event_type::game_over>( is_suicide, sLastWords );
1140 // Struck the save_player_data here to forestall Weirdness
1141 std::string char_filename = generate_memorial_filename( u.name );
1142 move_save_to_graveyard( char_filename );
1143 write_memorial_file( char_filename, sLastWords );
1144 memorial().clear();
1145 std::vector<std::string> characters = list_active_saves();
1146 // remove current player from the active characters list, as they are dead
1147 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1148 characters.end(), u.get_save_id() );
1149 if( curchar != characters.end() ) {
1150 characters.erase( curchar );
1151 }
1152
1153 if( characters.empty() ) {
1154 bool queryDelete = false;
1155 bool queryReset = false;
1156
1157 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1158 bool decided = false;
1159 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1160 "will not all reset when starting a new character in an "
1161 "already-played world. This can lead to some strange "
1162 "behavior.\n\n"
1163 "Are you sure you wish to keep this world?"
1164 );
1165
1166 while( !decided ) {
1167 uilist smenu;
1168 smenu.allow_cancel = false;
1169 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1170 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1171 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1172 smenu.query();
1173
1174 switch( smenu.ret ) {
1175 case 0:
1176 queryReset = true;
1177 decided = true;
1178 break;
1179 case 1:
1180 queryDelete = true;
1181 decided = true;
1182 break;
1183 case 2:
1184 decided = query_yn( buffer );
1185 break;
1186 }
1187 }
1188 }
1189
1190 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1191 world_generator->delete_world( world_generator->active_world->world_name, true );
1192
1193 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1194 world_generator->delete_world( world_generator->active_world->world_name, false );
1195 }
1196 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1197 std::string tmpmessage;
1198 for( auto &character : characters ) {
1199 tmpmessage += "\n ";
1200 tmpmessage += character;
1201 }
1202 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1203 }
1204 if( gamemode ) {
1205 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1206 }
1207 }
1208
1209 //Reset any offset due to driving
1211
1212 //clear all sound channels
1218
1219 MAPBUFFER.clear();
1221
1222#if defined(__ANDROID__)
1223 quick_shortcuts_map.clear();
1224#endif
1225 return true;
1226}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1538
std::string get_save_id() const
Definition: avatar.h:88
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2474
bool save_maps()
Definition: game.cpp:2673
std::unique_ptr< special_game > gamemode
Definition: game.h:1054
void death_screen()
Definition: game.cpp:2423
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:11977
bool save_factions_missions_npcs()
Definition: game.cpp:2659
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11001
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:881
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:2772
std::vector< std::string > list_active_saves()
Returns a list of currently active character saves.
Definition: game.cpp:2757
bool save_artifacts()
Definition: game.cpp:2667
memorial_logger & memorial()
Definition: game.cpp:2722
void reset_npc_dispositions()
Definition: game.cpp:2631
int monster_kill_count() const
void clear()
Delete all buffered submaps.
Definition: mapbuffer.cpp:45
string_input_popup & window(const catacurses::window &w, point start, int endx)
Set the window area where to display the input text.
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:915
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
std::unique_ptr< game > g
Definition: game.cpp:281
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, point begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1631
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1616
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1615
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, point p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2081
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void mvwputch(const catacurses::window &w, point p, nc_color FG, int ch)
Definition: output.cpp:477
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2089
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
overmapbuffer overmap_buffer
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), mapbuffer::clear(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), avatar::get_save_id(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_saves(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4026 of file game.cpp.

4027{
4028 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4029 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4030 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4031
4032 bool npc_is_dead = false;
4033 // can't use all_npcs as that does not include dead ones
4034 for( const auto &n : active_npc ) {
4035 if( n->is_dead() ) {
4036 n->die( nullptr ); // make sure this has been called to create corpses etc.
4037 npc_is_dead = true;
4038 }
4039 }
4040
4041 if( monster_is_dead ) {
4042 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4043 critter_tracker->remove_dead();
4044 }
4045
4046 if( npc_is_dead ) {
4047 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4048 if( ( *it )->is_dead() ) {
4049 remove_npc_follower( ( *it )->getID() );
4050 overmap_buffer.remove_npc( ( *it )->getID() );
4051 it = active_npc.erase( it );
4052 } else {
4053 it++;
4054 }
4055 }
4056 }
4057
4058 critter_died = false;
4059}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1885
pimpl< Creature_tracker > critter_tracker
Definition: game.h:972
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1036
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1048
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 4722 of file game.cpp.

4723{
4724 critter_tracker->clear();
4725}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5166 of file game.cpp.

5167{
5168 static const itype_id fuel_type_animal( "animal" );
5169 int veh_part = -1;
5170 vehicle *veh = remoteveh();
5171 if( veh == nullptr ) {
5172 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5173 veh = &vp->vehicle();
5174 veh_part = vp->part_index();
5175 }
5176 }
5177 if( veh != nullptr && veh->player_in_control( u ) &&
5178 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5179 veh->use_controls( u.pos() );
5180 } else if( veh && veh->player_in_control( u ) &&
5181 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5182 u.controlling_vehicle = false;
5183 add_msg( m_info, _( "You let go of the reins." ) );
5184 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5185 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5186 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5187 u.in_vehicle ) {
5188 if( u.has_trait( trait_WAYFARER ) ) {
5189 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5190 return;
5191 }
5192 if( !veh->interact_vehicle_locked() ) {
5193 veh->handle_potential_theft( u );
5194 return;
5195 }
5196 if( veh->engine_on ) {
5197 if( !veh->handle_potential_theft( u ) ) {
5198 return;
5199 }
5200 u.controlling_vehicle = true;
5201 add_msg( _( "You take control of the %s." ), veh->name );
5202 } else {
5203 if( !veh->handle_potential_theft( u ) ) {
5204 return;
5205 }
5206 veh->start_engines( true );
5207 }
5208 } else { // Start looking for nearby vehicle controls.
5209 int num_valid_controls = 0;
5210 std::optional<tripoint> vehicle_position;
5211 std::optional<vpart_reference> vehicle_controls;
5212 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5213 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5214 const std::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5215 if( controls ) {
5216 num_valid_controls++;
5217 vehicle_position = elem;
5218 vehicle_controls = controls;
5219 }
5220 }
5221 }
5222 if( num_valid_controls < 1 ) {
5223 add_msg( _( "No vehicle controls found." ) );
5224 return;
5225 } else if( num_valid_controls > 1 ) {
5226 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5227 if( !vehicle_position ) {
5228 return;
5229 }
5230 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5231 if( vp ) {
5232 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5233 if( !vehicle_controls ) {
5234 add_msg( _( "The vehicle doesn't have controls there." ) );
5235 return;
5236 }
5237 } else {
5238 add_msg( _( "No vehicle there." ) );
5239 return;
5240 }
5241 }
5242 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5243 if( vehicle_controls ) {
5244 veh = &vehicle_controls->vehicle();
5245 if( !veh->handle_potential_theft( u ) ) {
5246 return;
5247 }
5248 veh->use_controls( *vehicle_position );
5249 //May be folded up (destroyed), so need to re-get it
5250 veh = g->remoteveh();
5251 }
5252 }
5253 if( veh ) {
5254 // If we reached here, we gained control of a vehicle.
5255 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5256 for( const tripoint &target : veh->get_points() ) {
5257 u.clear_memorized_tile( m.getabs( target ) );
5258 }
5259 veh->is_following = false;
5260 veh->is_patrolling = false;
5261 veh->autopilot_on = false;
5262 veh->is_autodriving = false;
5263 }
5264}
std::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1026
bool in_vehicle
Definition: character.h:1545
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:168
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2253
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8711
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1068
Simple wrapper to forward functions that may return a std::optional to vpart_position.
std::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2482
bool engine_on
Definition: vehicle.h:2014
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6762
std::string name
Definition: vehicle.h:1874
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1032
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:252
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2546
bool autopilot_on
Definition: vehicle.h:2022
bool is_autodriving
Definition: vehicle.h:2007
bool handle_potential_theft(avatar &you, bool check_only=false, bool prompt=true)
Handle potential vehicle theft.
Definition: vehicle.cpp:4388
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, optional_vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 2909 of file game.cpp.

2910{
2912 if( !ui ) {
2913 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
2914 ui->on_redraw( []( const ui_adaptor & ) {
2915 g->draw();
2916 } );
2917 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
2918 // remove some space for the sidebar, this is the maximal space
2919 // (using standard font) that the terrain window can have
2920 const int sidebar_left = panel_manager::get_manager().get_width_left();
2921 const int sidebar_right = panel_manager::get_manager().get_width_right();
2922
2924 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
2927
2928 /**
2929 * In tiles mode w_terrain can have a different font (with a different
2930 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
2931 * might have a different dimension then the normal font used everywhere else.
2932 *
2933 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
2934 * be displayed in w_terrain (using it's specific tile dimension), not
2935 * including partially drawn squares at the right/bottom. You should
2936 * use it whenever you want to draw specific squares in that window or to
2937 * determine whether a specific square is draw on screen (or outside the screen
2938 * and needs scrolling).
2939 *
2940 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
2941 * w_terrain in the standard font dimension (the font that everything else uses).
2942 * You usually don't have to use it, expect for positioning of windows,
2943 * because the window positions use the standard font dimension.
2944 *
2945 * The code here calculates size available for w_terrain, caps it at
2946 * max_view_size (the maximal view range than any character can have at
2947 * any time).
2948 * It is stored in TERRAIN_WINDOW_*.
2949 */
2951
2952 // Position of the player in the terrain window, it is always in the center
2955
2957 point( sidebar_left, 0 ) );
2958
2959 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
2961
2962 // need to init in order to avoid crash. gets updated by the panel code.
2964
2965 ui.position_from_window( catacurses::stdscr );
2966 } );
2967 ui->mark_resize();
2968 }
2969 return ui;
2970}
catacurses::window w_pixel_minimap
Definition: game.h:990
catacurses::window w_minimap_ptr
Definition: game.h:1027
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1073
catacurses::window w_minimap
Definition: game.h:989
catacurses::window w_terrain_ptr
Definition: game.h:1026
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2183
int get_width_left()
Definition: panels.cpp:2191
Adaptor between UI code and the UI management system.
Definition: ui_manager.h:65
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
Definition: overmap_ui.h:17
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 886 of file game.cpp.

887{
888 if( !get_option<bool>( "STATIC_NPC" ) ||
889 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
890 return; //Do not generate a starting npc.
891 }
892
893 //We don't want more than one starting npc per starting location
894 const int radius = 1;
895 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
896 return; //There is already an NPC in this starting location
897 }
898
899 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
900 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
901 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
903 tmp->form_opinion( u );
904 tmp->set_attitude( NPCATT_NULL );
905 //This sets the NPC mission. This NPC remains in the starting location.
906 tmp->mission = NPC_MISSION_SHELTER;
907 tmp->chatbin.first_topic = "TALK_SHELTER";
908 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
909 tmp->set_fac( faction_id( "no_faction" ) );
910 //One random starting NPC mission
911 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
912 tmp->getID() ) );
913}
int get_levy() const
Definition: game.cpp:11867
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:11862
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:144
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:265
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4527 of file game.cpp.

4528{
4529 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4530 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4531 return nullptr;
4532 }
4533 // if we wanted to check for an NPC / player / avatar,
4534 // there is sometimes a monster AND an NPC/player there at the same time.
4535 // because the NPC/player etc may be riding that monster.
4536 // so only return the monster if we were actually looking for a monster.
4537 // otherwise, keep looking for the rider.
4538 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4539 // which is ok for the occasions where that happens.
4540 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4541 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4542 std::is_same<T, const Creature>::value ) ) {
4543 return dynamic_cast<T *>( mon_ptr.get() );
4544 }
4545 }
4546 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4547 if( p == u.pos() ) {
4548 return dynamic_cast<T *>( &u );
4549 }
4550 }
4551 for( auto &cur_npc : active_npc ) {
4552 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4553 return dynamic_cast<T *>( cur_npc.get() );
4554 }
4555 }
4556 return nullptr;
4557}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4560 of file game.cpp.

4561{
4562 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4563}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4606 of file game.cpp.

4607{
4608 if( id == u.getID() ) {
4609 // player is always alive, therefore no is-dead check
4610 return dynamic_cast<T *>( &u );
4611 }
4612 return find_npc( id );
4613}
character_id getID() const
Definition: character.cpp:484
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1874

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2423 of file game.cpp.

2424{
2425 gamemode->game_over();
2430 follower_ids.clear();
2432}
diary * get_avatar_diary()
Definition: avatar.cpp:369
void death_entry()
Definition: diary.cpp:672
stats_tracker & stats()
Definition: game.cpp:2717
void disp_NPC_epilogues()
Definition: game.cpp:2796
void display_faction_epilogues()
Definition: game.cpp:2813
void display_messages()
Definition: messages.cpp:827
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, diary::death_entry(), disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, avatar::get_avatar_diary(), get_kill_tracker(), show_scores_ui(), stats(), and u.

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11001 of file game.cpp.

11002{
11003 if( !critter.is_hallucination() ) {
11004 // hallucinations aren't stored, they come and go as they like,
11006 }
11007
11008 critter.on_unload();
11009 remove_zombie( critter );
11010 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11011 critter.set_hp( 0 );
11012}
void remove_zombie(const monster &critter)
Definition: game.cpp:4717
bool is_hallucination() const override
Definition: monster.cpp:2675
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:3002
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1664
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 8624 of file game.cpp.

8625{
8626 monster *const mon_ptr = critter_at<monster>( p );
8627 if( !mon_ptr ) {
8628 return false;
8629 }
8630 monster &critter = *mon_ptr;
8631 if( critter.friendly == 0 || critter.has_effect( effect_pet ) ||
8632 critter.has_flag( MF_RIDEABLE_MECH ) ||
8633 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
8634 // Can only disable / reprogram friendly monsters
8635 return false;
8636 }
8637 const auto mid = critter.type->id;
8638 const auto mon_item_id = critter.type->revert_to_itype;
8639 if( !mon_item_id.is_empty() &&
8640 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
8641
8642 u.moves -= 100;
8643 m.add_item_or_charges( p, critter.to_item() );
8644 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
8645 for( auto &ammodef : critter.ammo ) {
8646 if( ammodef.second > 0 ) {
8647 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
8648 }
8649 }
8650 }
8651 remove_zombie( critter );
8652 return true;
8653 }
8654 // Manhacks are special, they have their own menu here.
8655 if( mid == mon_manhack ) {
8656 int choice = UILIST_CANCEL;
8657 if( critter.has_effect( effect_docile ) ) {
8658 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
8659 } else {
8660 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
8661 }
8662 switch( choice ) {
8663 case 0:
8664 if( critter.has_effect( effect_docile ) ) {
8665 critter.remove_effect( effect_docile );
8666 if( one_in( 3 ) ) {
8667 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
8668 critter.name() );
8669 }
8670 } else {
8671 critter.add_effect( effect_docile, 1_turns, num_bp );
8672 if( one_in( 3 ) ) {
8673 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
8674 critter.name() );
8675 }
8676 }
8677 u.moves -= 100;
8678 return true;
8679 default:
8680 break;
8681 }
8682 }
8683 return false;
8684}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1143
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4286
bool has_flag(m_flag f) const override
Definition: monster.cpp:898
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2815
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1840
int friendly
Definition: monster.h:470
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:493
std::map< itype_id, int > ammo
Definition: monster.h:511
static const efftype_id effect_pet("pet")
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:364
constexpr point xy() const
Definition: point.h:206
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, effect_pet, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 2796 of file game.cpp.

2797{
2798 // TODO: This search needs to be expanded to all NPCs
2799 for( auto elem : follower_ids ) {
2801 if( !guy ) {
2802 continue;
2803 }
2804 const auto new_win = []() {
2806 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2807 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2808 };
2809 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
2810 }
2811}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 2847 of file game.cpp.

2848{
2849 const tripoint_abs_omt ppos = u.global_omt_location();
2850 const tripoint &lpos = u.pos();
2851 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
2852 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
2853
2855 ui_adaptor ui;
2856 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
2859 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
2860 ui.position_from_window( w );
2861 } );
2862 ui.mark_resize();
2863 ui.on_redraw( [&]( const ui_adaptor & ) {
2864 werase( w );
2865 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
2866 // NOLINTNEXTLINE(cata-use-named-point-constants)
2867 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
2868 size_t i;
2869 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
2870 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
2871 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
2872 apos.to_string() );
2873 }
2874 for( const monster &m : all_monsters() ) {
2875 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
2876 m.posx(), m.posy(), m.posz() );
2877 ++i;
2878 }
2879 wnoutrefresh( w );
2880 } );
2881
2882 input_context ctxt( "DISP_NPCS" );
2883 ctxt.register_action( "CONFIRM" );
2884 ctxt.register_action( "QUIT" );
2885 ctxt.register_action( "HELP_KEYBINDINGS" );
2886 bool stop = false;
2887 while( !stop ) {
2889 const std::string action = ctxt.handle_input();
2890 if( action == "CONFIRM" || action == "QUIT" ) {
2891 stop = true;
2892 }
2893 }
2894}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6247
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1384
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:34

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 2813 of file game.cpp.

2814{
2815 for( const auto &elem : faction_manager_ptr->all() ) {
2816 if( elem.second.known_by_u ) {
2817 const std::vector<std::string> epilogue = elem.second.epilogue();
2818 if( !epilogue.empty() ) {
2819 const auto new_win = []() {
2821 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
2822 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
2823 };
2824 scrollable_text( new_win, elem.second.name,
2825 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
2826 []( const std::string & lhs, const std::string & rhs ) -> std::string {
2827 return lhs + "\n" + rhs;
2828 } ) );
2829 }
2830 }
2831 }
2832}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:973

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11212 of file game.cpp.

11213{
11214 if( use_tiles ) {
11216 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11217 return;
11218 }
11219 uilist lighting_menu;
11220 std::vector<std::string> lighting_menu_strings{
11221 "Global lighting conditions"
11222 };
11223
11224 int count = 0;
11225 for( const auto &menu_str : lighting_menu_strings ) {
11226 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11227 }
11228
11229 lighting_menu.w_y_setup = 0;
11230 lighting_menu.query();
11231 if( ( lighting_menu.ret >= 0 ) &&
11232 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11233 g->displaying_lighting_condition = lighting_menu.ret;
11234 }
11235 }
11236}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11108
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11103 of file game.cpp.

11104{
11106}
std::optional< action_id > displaying_overlays
Definition: game.h:918

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11238 of file game.cpp.

11239{
11240 if( use_tiles ) {
11242 }
11243}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11117 of file game.cpp.

11118{
11119 if( use_tiles ) {
11121 } else {
11122 int div;
11123 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11124 if( !got_value || div < 1 ) {
11125 add_msg( _( "Never mind." ) );
11126 return;
11127 }
11128 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11129 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11130 } );
11131 g->add_draw_callback( scent_cb );
11132
11135 }
11136}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1303
tripoint view_offset
Definition: player.h:233
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11138 of file game.cpp.

11139{
11140 if( use_tiles ) {
11142 }
11143}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11108 of file game.cpp.

11109{
11110 if( display_overlay_state( action ) ) {
11111 displaying_overlays.reset();
11112 } else {
11114 }
11115}
bool display_overlay_state(action_id)
Definition: game.cpp:11103

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11245 of file game.cpp.

11246{
11247 if( use_tiles ) {
11249 }
11250}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11145 of file game.cpp.

11146{
11147 if( use_tiles ) {
11149 }
11150}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11152 of file game.cpp.

11153{
11154 if( use_tiles ) {
11157 std::vector< tripoint > locations;
11158 uilist creature_menu;
11159 int num_creatures = 0;
11160 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11161 locations.emplace_back( g->u.pos() ); // add player first.
11162 for( const Creature &critter : g->all_creatures() ) {
11163 if( critter.is_player() ) {
11164 continue;
11165 }
11166 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11167 locations.emplace_back( critter.pos() );
11168 }
11169
11170 pointmenu_cb callback( locations );
11171 creature_menu.callback = &callback;
11172 creature_menu.w_y_setup = 0;
11173 creature_menu.query();
11174 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11175 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11177 }
11178 } else {
11180 }
11181 }
11182}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:4707
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1009
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1348 of file game.cpp.

1349{
1350 if( is_game_over() ) {
1351 return cleanup_at_end();
1352 }
1353 // Actual stuff
1354 if( new_game ) {
1355 new_game = false;
1356 } else {
1357 gamemode->per_turn();
1358 calendar::turn += 1_turns;
1359 }
1360
1361 // starting a new turn, clear out temperature cache
1363 weather.clear_temp_cache();
1364
1365 if( npcs_dirty ) {
1366 load_npcs();
1367 }
1368
1371 // If controlling a vehicle that is owned by someone else
1373 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1374 if( veh && !veh->handle_potential_theft( u, true ) ) {
1375 veh->handle_potential_theft( u, false, false );
1376 }
1377 }
1378 // If riding a horse - chance to spook
1379 if( u.is_mounted() ) {
1381 }
1382 if( calendar::once_every( 1_days ) ) {
1384 }
1385
1386 // Move hordes every 2.5 min
1389 // Hordes that reached the reality bubble need to spawn,
1390 // make them spawn in invisible areas only.
1391 m.spawn_monsters( false );
1392 }
1393
1395
1396 u.update_body();
1397
1398 // Auto-save if autosave is enabled
1399 if( get_option<bool>( "AUTOSAVE" ) &&
1400 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1401 !u.is_dead_state() ) {
1402 autosave();
1403 }
1404
1405 weather.update_weather();
1407
1411 // Process NPC sound events before they move or they hear themselves talking
1412 for( npc &guy : all_npcs() ) {
1413 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1415 }
1416 }
1417
1418 // Process sound events into sound markers for display to the player.
1420
1421 if( u.is_deaf() ) {
1423 }
1424
1425 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1426 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1427 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1428 cleanup_dead();
1430 // Process any new sounds the player caused during their turn.
1431 for( npc &guy : all_npcs() ) {
1432 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1434 }
1435 }
1438 wait_popup.reset();
1440 }
1441
1442 if( queue_screenshot ) {
1446 queue_screenshot = false;
1447 }
1448
1449 if( handle_action() ) {
1451 u.action_taken();
1452 }
1453
1454 if( is_game_over() ) {
1455 return cleanup_at_end();
1456 }
1457
1458 if( uquit == QUIT_WATCH ) {
1459 break;
1460 }
1461 if( u.activity ) {
1463 }
1464 }
1465 // Reset displayed sound markers now that the turn is over.
1466 // We only want this to happen if the player had a chance to examine the sounds.
1468 }
1469 }
1470
1471 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1472 // Still have a view offset, but might not be driving anymore,
1473 // or the option has been deactivated,
1474 // might also happen when someone dives from a moving car.
1475 // or when using the handbrake.
1476 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1477 calc_driving_offset( veh );
1478 }
1479
1480 // No-scent debug mutation has to be processed here or else it takes time to start working
1481 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1482 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1485 }
1486 scent.update( u.pos(), m );
1487
1488 // We need floor cache before checking falling 'n stuff
1490
1493 m.vehmove();
1494 m.process_fields();
1495 m.process_items();
1498
1499 // Apply sounds from previous turn to monster and NPC AI.
1501 // Update vision caches for monsters. If this turns out to be expensive,
1502 // consider a stripped down cache just for monsters.
1503 m.build_map_cache( get_levz(), true );
1504 monmove();
1505 if( calendar::once_every( 5_minutes ) ) {
1507 }
1508 if( calendar::once_every( 10_seconds ) ) {
1509 for( const tripoint &elem : m.get_furn_field_locations() ) {
1510 const auto &furn = m.furn( elem ).obj();
1511 for( const emit_id &e : furn.emissions ) {
1512 m.emit_field( elem, e );
1513 }
1514 }
1515 }
1518 u.process_turn();
1519
1521 cleanup_dead();
1522
1523 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1526 }
1527
1528 if( get_levz() >= 0 && !u.is_underwater() ) {
1529 handle_weather_effects( weather.weather_id );
1530 }
1531
1532 const bool player_is_sleeping = u.has_effect( effect_sleep );
1533 bool wait_redraw = false;
1534 std::string wait_message;
1535 time_duration wait_refresh_rate;
1536 if( player_is_sleeping ) {
1537 wait_redraw = true;
1538 wait_message = _( "Wait till you wake up…" );
1539 wait_refresh_rate = 30_minutes;
1540 if( calendar::once_every( 1_hours ) ) {
1542 }
1543 } else if( u.has_destination() ) {
1544 wait_redraw = true;
1545 wait_message = _( "Travelling…" );
1546 wait_refresh_rate = 15_turns;
1547 } else if( const std::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1548 wait_redraw = true;
1549 wait_message = *progress;
1550 if( u.activity.id() == ACT_AUTODRIVE ) {
1551 wait_refresh_rate = 1_turns;
1552 } else {
1553 wait_refresh_rate = 5_minutes;
1554 }
1555 }
1556 if( wait_redraw ) {
1558 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1559 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1561 }
1562
1563 // Avoid redrawing the main UI every time due to invalidation
1565 wait_popup = std::make_unique<static_popup>();
1566 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1570 }
1571 } else {
1572 // Nothing to wait for now
1573 wait_popup.reset();
1575 }
1576
1579 u.apply_wetness_morale( weather.temperature );
1580
1581 if( calendar::once_every( 1_minutes ) ) {
1582 u.update_morale();
1583 }
1584
1585 if( calendar::once_every( 9_turns ) ) {
1587 }
1588
1589 if( !u.is_deaf() ) {
1591 }
1596
1597 // reset player noise
1598 u.volume = 0;
1599
1600 return false;
1601}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:8972
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:802
bool check_mount_is_spooked()
Definition: character.cpp:1027
void process_turn() override
Handles end-of-turn processing.
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5196
bool is_mounted() const
Definition: character.cpp:1068
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8731
bool is_dead_state() const override
Returns true if the character should be dead.
Definition: character.cpp:489
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9099
bool is_deaf() const
Definition: character.cpp:4491
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4670
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1809
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1779
virtual bool is_underwater() const
Definition: creature.cpp:171
int get_levz() const
Definition: game.cpp:11872
void overmap_npc_move()
Definition: game.cpp:4187
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:11982
void monmove()
Definition: game.cpp:4061
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1666
void add_artifact_dreams()
Definition: game.cpp:11814
int moves_since_last_save
Definition: game.h:1039
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7143
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1246
bool cleanup_at_end()
Definition: game.cpp:942
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1075
bool queue_screenshot
Definition: game.h:1018
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11303
void process_activity()
Definition: game.cpp:1655
void update_stair_monsters()
Definition: game.cpp:10792
void process_voluntary_act_interrupt()
Definition: game.cpp:1615
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:811
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1046
void cleanup_dead()
Definition: game.cpp:4026
bool is_game_over()
Definition: game.cpp:2370
void perhaps_add_random_npc()
Definition: game.cpp:11039
void mon_info_update()
Definition: game.cpp:3825
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:8156
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2350
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1927
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7853
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7812
void vehmove()
Definition: map.cpp:473
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1562
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1407
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8322
void process_items()
Definition: map.cpp:4672
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
std::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
int volume
Definition: player.h:236
int scent
Definition: player.h:245
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:150
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
void update_body_wetness(Character &who, const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1919
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1612
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1607
void do_danger_music()
Definition: sounds.cpp:1611
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1613
void do_fatigue()
Definition: sounds.cpp:1632
void remove_hearing_loss()
Definition: sounds.cpp:1608
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), Character::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), Character::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), character_funcs::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3084 of file game.cpp.

3085{
3086 if( test_mode ) {
3087 return;
3088 }
3089
3090 //temporary fix for updating visibility for minimap
3091 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3094
3095 werase( w_terrain );
3096 draw_ter();
3097 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3098 shared_ptr_fast<draw_callback_t> cb = it->lock();
3099 if( cb ) {
3100 ( *cb )();
3101 ++it;
3102 } else {
3103 it = draw_callbacks.erase( it );
3104 }
3105 }
3107
3108 draw_panels( true );
3109}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:985
void draw_panels(bool force_draw=false)
Definition: game.cpp:3111
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3225
void update_visibility_cache(int zlev)
Definition: map.cpp:5701
int z
Definition: point.h:138

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 1023 of file animation.cpp.

1024{
1025}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 578 of file animation.cpp.

580{
581 draw_bullet_curses( m, t, bullet, &trajectory[i] );
582}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:460
std::vector< tripoint > trajectory
Definition: ranged.h:37

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3207 of file game.cpp.

3208{
3209 draw_critter_internal( w_terrain, critter, center, false, m, u );
3210}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3174

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3212 of file game.cpp.

3213{
3214 draw_critter_internal( w_terrain, critter, center, true, m, u );
3215}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 784 of file animation.cpp.

785{
786 const tripoint rp = relative_view_pos( *this, p );
787 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
788}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:128
void mvwputch_inv(const catacurses::window &w, point p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 979 of file animation.cpp.

980{
981}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 940 of file animation.cpp.

941{
942}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 953 of file animation.cpp.

954{
955}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 797 of file animation.cpp.

798{
799 // Do nothing
800}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 641 of file animation.cpp.

642{
643 draw_hit_mon_curses( p, m, u, dead );
644}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:612

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 686 of file animation.cpp.

687{
688 draw_hit_player_curses( *this, p, dam );
689}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:649

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 993 of file animation.cpp.

995{
996}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 770 of file animation.cpp.

771{
772 draw_line_curses( *this, points );
773}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:750

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 737 of file animation.cpp.

739{
740 if( !u.sees( p ) ) {
741 return;
742 }
743
744 draw_line_curses( *this, center, points, noreveal );
745}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5675 of file game.cpp.

5676{
5677 if( !liveview.is_enabled() ) {
5678#if defined( TILES )
5679 if( is_draw_tiles_mode() ) {
5680 draw_cursor( lp );
5681 return;
5682 }
5683#endif
5684 const tripoint view_center = u.pos() + u.view_offset;
5685 visibility_type visibility = VIS_HIDDEN;
5686 const bool inbounds = m.inbounds( lp );
5687 if( inbounds ) {
5688 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5689 }
5690 if( visibility == VIS_CLEAR ) {
5691 const Creature *const creature = critter_at( lp, true );
5692 if( creature != nullptr && u.sees( *creature ) ) {
5693 creature->draw( w_terrain, view_center, true );
5694 } else {
5695 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5696 }
5697 } else {
5698 std::string visibility_indicator;
5699 nc_color visibility_indicator_color = c_white;
5700 switch( visibility ) {
5701 case VIS_CLEAR:
5702 // Already handled by the outer if statement
5703 break;
5704 case VIS_BOOMER:
5705 case VIS_BOOMER_DARK:
5706 visibility_indicator = '#';
5707 visibility_indicator_color = c_pink;
5708 break;
5709 case VIS_DARK:
5710 visibility_indicator = '#';
5711 visibility_indicator_color = c_dark_gray;
5712 break;
5713 case VIS_LIT:
5714 visibility_indicator = '#';
5715 visibility_indicator_color = c_light_gray;
5716 break;
5717 case VIS_HIDDEN:
5718 visibility_indicator = 'x';
5719 visibility_indicator_color = c_white;
5720 break;
5721 }
5722
5723 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
5724 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
5725 }
5726 }
5727}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:784
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4527
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7863
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5755
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:764
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5933
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2075
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:180

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3285 of file game.cpp.

3286{
3287
3288 // Draw the box
3289 werase( w_minimap );
3291
3292 const tripoint_abs_omt curs = u.global_omt_location();
3293 const point_abs_omt curs2( curs.xy() );
3295 bool drew_mission = targ == overmap::invalid_tripoint;
3296
3297 for( int i = -2; i <= 2; i++ ) {
3298 for( int j = -2; j <= 2; j++ ) {
3299 const point_abs_omt om( curs2 + point( i, j ) );
3300 nc_color ter_color;
3301 tripoint_abs_omt omp( om, get_levz() );
3302 std::string ter_sym;
3303 const bool seen = overmap_buffer.seen( omp );
3304 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3305 if( overmap_buffer.has_note( omp ) ) {
3306
3307 const std::string &note_text = overmap_buffer.note( omp );
3308
3309 ter_color = c_yellow;
3310 ter_sym = "N";
3311
3312 int symbolIndex = note_text.find( ':' );
3313 int colorIndex = note_text.find( ';' );
3314
3315 bool symbolFirst = symbolIndex < colorIndex;
3316
3317 if( colorIndex > -1 && symbolIndex > -1 ) {
3318 if( symbolFirst ) {
3319 if( colorIndex > 4 ) {
3320 colorIndex = -1;
3321 }
3322 if( symbolIndex > 1 ) {
3323 symbolIndex = -1;
3324 colorIndex = -1;
3325 }
3326 } else {
3327 if( symbolIndex > 4 ) {
3328 symbolIndex = -1;
3329 }
3330 if( colorIndex > 2 ) {
3331 colorIndex = -1;
3332 }
3333 }
3334 } else if( colorIndex > 2 ) {
3335 colorIndex = -1;
3336 } else if( symbolIndex > 1 ) {
3337 symbolIndex = -1;
3338 }
3339
3340 if( symbolIndex > -1 ) {
3341 int symbolStart = 0;
3342 if( colorIndex > -1 && !symbolFirst ) {
3343 symbolStart = colorIndex + 1;
3344 }
3345 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3346 }
3347
3348 if( colorIndex > -1 ) {
3349
3350 int colorStart = 0;
3351
3352 if( symbolIndex > -1 && symbolFirst ) {
3353 colorStart = symbolIndex + 1;
3354 }
3355
3356 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3357
3358 if( sym.length() == 2 ) {
3359 if( sym == "br" ) {
3360 ter_color = c_brown;
3361 } else if( sym == "lg" ) {
3362 ter_color = c_light_gray;
3363 } else if( sym == "dg" ) {
3364 ter_color = c_dark_gray;
3365 }
3366 } else {
3367 char colorID = sym.c_str()[0];
3368 if( colorID == 'r' ) {
3369 ter_color = c_light_red;
3370 } else if( colorID == 'R' ) {
3371 ter_color = c_red;
3372 } else if( colorID == 'g' ) {
3373 ter_color = c_light_green;
3374 } else if( colorID == 'G' ) {
3375 ter_color = c_green;
3376 } else if( colorID == 'b' ) {
3377 ter_color = c_light_blue;
3378 } else if( colorID == 'B' ) {
3379 ter_color = c_blue;
3380 } else if( colorID == 'W' ) {
3381 ter_color = c_white;
3382 } else if( colorID == 'C' ) {
3383 ter_color = c_cyan;
3384 } else if( colorID == 'c' ) {
3385 ter_color = c_light_cyan;
3386 } else if( colorID == 'P' ) {
3387 ter_color = c_pink;
3388 } else if( colorID == 'm' ) {
3389 ter_color = c_magenta;
3390 }
3391 }
3392 }
3393 } else if( !seen ) {
3394 ter_sym = " ";
3395 ter_color = c_black;
3396 } else if( vehicle_here ) {
3397 ter_color = c_cyan;
3398 ter_sym = "c";
3399 } else {
3400 const oter_id &cur_ter = overmap_buffer.ter( omp );
3401 ter_sym = cur_ter->get_symbol();
3402 if( overmap_buffer.is_explored( omp ) ) {
3403 ter_color = c_dark_gray;
3404 } else {
3405 ter_color = cur_ter->get_color();
3406 }
3407 }
3408 if( !drew_mission && targ.xy() == omp.xy() ) {
3409 // If there is a mission target, and it's not on the same
3410 // overmap terrain as the player character, mark it.
3411 // TODO: Inform player if the mission is above or below
3412 drew_mission = true;
3413 if( i != 0 || j != 0 ) {
3414 ter_color = red_background( ter_color );
3415 }
3416 }
3417 if( i == 0 && j == 0 ) {
3418 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3419 } else {
3420 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3421 }
3422 }
3423 }
3424
3425 // Print arrow to mission if we have one!
3426 if( !drew_mission ) {
3427 double slope = curs2.x() != targ.x() ?
3428 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3429
3430 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3431 if( targ.y() > curs2.y() ) {
3432 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3433 } else {
3434 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3435 }
3436 } else {
3437 int arrowx = -1;
3438 int arrowy = -1;
3439 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3440 arrowy = targ.y() > curs2.y() ? 6 : 0;
3441 arrowx =
3442 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3443 if( arrowx < 0 ) {
3444 arrowx = 0;
3445 }
3446 if( arrowx > 6 ) {
3447 arrowx = 6;
3448 }
3449 } else {
3450 arrowx = targ.x() > curs2.x() ? 6 : 0;
3451 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3452 if( arrowy < 0 ) {
3453 arrowy = 0;
3454 }
3455 if( arrowy > 6 ) {
3456 arrowy = 6;
3457 }
3458 }
3459 char glyph = '*';
3460 if( targ.z() > u.posz() ) {
3461 glyph = '^';
3462 } else if( targ.z() < u.posz() ) {
3463 glyph = 'v';
3464 }
3465
3466 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3467 }
3468 }
3469
3470 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3471 for( int i = -3; i <= 3; i++ ) {
3472 for( int j = -3; j <= 3; j++ ) {
3473 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3474 continue; // only do hordes on the border, skip inner map
3475 }
3476 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3478 if( overmap_buffer.seen( omp )
3479 && g->u.overmap_los( omp, sight_points ) ) {
3480 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3481 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3482 }
3483 }
3484 }
3485 }
3486
3488}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:206
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, point p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 1037 of file animation.cpp.

1039{
1040}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3111 of file game.cpp.

3112{
3113 static int previous_turn = -1;
3114 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3115 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3116 auto &mgr = panel_manager::get_manager();
3117 int y = 0;
3118 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3119 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3120 int log_height = 0;
3121 for( const window_panel &panel : mgr.get_current_layout() ) {
3122 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3123 log_height += panel.get_height() + spacer;
3124 }
3125 }
3126 log_height = std::max( TERMY - log_height, 3 );
3127 for( const window_panel &panel : mgr.get_current_layout() ) {
3128 if( panel.render() ) {
3129 // height clamped to window height.
3130 int h = std::min( panel.get_height(), TERMY - y );
3131 if( h == -2 ) {
3132 h = log_height;
3133 }
3134 h += spacer;
3135 if( panel.toggle && panel.render() && h > 0 ) {
3136 if( panel.always_draw || draw_this_turn ) {
3137 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3138 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3139 }
3140 if( show_panel_adm ) {
3141 const std::string panel_name = _( panel.get_name() );
3142 const int panel_name_width = utf8_width( panel_name );
3143 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3144 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3145 werase( label );
3146 mvwprintz( label, point_zero, c_light_red, panel_name );
3148 label = catacurses::newwin( h, 1,
3149 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3150 werase( label );
3151 if( h == 1 ) {
3153 } else {
3155 for( int i = 1; i < h - 1; i++ ) {
3157 }
3158 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3159 }
3161 }
3162 y += h;
3163 }
3164 }
3165 }
3166 previous_turn = current_turn;
3167}
bool show_panel_adm
Definition: game.h:1013
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:579

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3169 of file game.cpp.

3170{
3171 w_pixel_minimap = w;
3172}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 914 of file animation.cpp.

915{
916}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 865 of file animation.cpp.

866{
867 draw_sct_curses( *this );
868}
void draw_sct_curses(const game &g)
Definition: animation.cpp:832

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3225 of file game.cpp.

3226{
3228 draw_sounds );
3229}
bool is_looking
Definition: game.h:224

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3231 of file game.cpp.

3232{
3234
3235 m.draw( w_terrain, center );
3236
3237 if( draw_sounds ) {
3239 }
3240
3241 for( Creature &critter : all_creatures() ) {
3242 draw_critter( critter, center );
3243 }
3244
3245 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3246 // Draw auto-move preview trail
3247 const tripoint &final_destination = destination_preview.back();
3248 tripoint line_center = u.pos() + u.view_offset;
3249 draw_line( final_destination, line_center, destination_preview, true );
3250 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3251 POSY - u.posy() ), c_white, 'X' );
3252 }
3253
3254 if( u.controlling_vehicle && !looking ) {
3255 draw_veh_dir_indicator( false );
3256 draw_veh_dir_indicator( true );
3257 }
3258 // Place the cursor over the player as is expected by screen readers.
3259 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3260}
int posx() const override
Definition: character.h:793
int posy() const override
Definition: character.h:796
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3207
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:11972
std::vector< tripoint > destination_preview
Definition: game.h:1065
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3277
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:737
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5805
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:2897
void wmove(const window &win, point p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 927 of file animation.cpp.

928{
929}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 6991 of file game.cpp.

6992{
6993 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
6994}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:6961

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 966 of file animation.cpp.

967{
968}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3277 of file game.cpp.

3278{
3279 if( const std::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3280 auto col = next ? c_white : c_dark_gray;
3281 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3282 }
3283}
std::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3262

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
point  mount 
)

Definition at line 1009 of file animation.cpp.

1011{
1012}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 824 of file animation.cpp.

825{
827}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 900 of file animation.cpp.

901{
902 draw_zones_curses( w_terrain, start, end, offset );
903}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:873

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8038 of file game.cpp.

8039{
8041}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2437
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8043 of file game.cpp.

8044{
8045 if( const std::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8046 u.drop( game_menus::inv::multidrop( u ), *pnt );
8047 }
8048}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 39 of file dump.cpp.

41{
42 try {
44 } catch( const std::exception &err ) {
45 std::cerr << "Error loading data from json: " << err.what() << std::endl;
46 return false;
47 }
48
49 std::vector<std::string> header;
50 std::vector<std::vector<std::string>> rows;
51
52 int scol = 0; // sorting column
53
54 std::map<std::string, standard_npc> test_npcs;
55 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
56 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
57 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
58 4, 8, 8, 8, 10 /* PER 10 */ );
59 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
60 4, 10, 8, 8, 8 /* STAT 10 */ );
61 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
62 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
64 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
65
66 std::map<std::string, item> test_items;
67 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
68 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
70 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
71 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
72
73 if( what == "AMMO" ) {
74 header = {
75 "Name", "Ammo", "Volume", "Weight", "Stack",
76 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
77 };
78 auto dump = [&rows]( const item & obj ) {
79 std::vector<std::string> r;
80 r.push_back( obj.tname( 1, false ) );
81 r.push_back( obj.ammo_type().str() );
82 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
83 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
84 r.push_back( std::to_string( obj.type->stack_size ) );
85 r.push_back( std::to_string( obj.type->ammo->range ) );
86 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
87 r.push_back( std::to_string( obj.type->ammo->recoil ) );
88 damage_instance damage = obj.type->ammo->damage;
89 r.push_back( std::to_string( damage.total_damage() ) );
90 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
91 rows.push_back( r );
92 };
93 for( const itype *e : item_controller->all() ) {
94 if( e->ammo ) {
95 dump( item( e, calendar::turn, item::solitary_tag {} ) );
96 }
97 }
98
99 } else if( what == "ARMOR" ) {
100 header = {
101 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
102 };
103 auto dump = [&rows]( const item & obj ) {
104 std::vector<std::string> r;
105 r.push_back( obj.tname( 1, false ) );
106 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
107 r.push_back( std::to_string( obj.get_warmth() ) );
108 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
109 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
110 r.push_back( std::to_string( obj.get_coverage() ) );
111 r.push_back( std::to_string( obj.bash_resist() ) );
112 r.push_back( std::to_string( obj.cut_resist() ) );
113 r.push_back( std::to_string( obj.bullet_resist() ) );
114 r.push_back( std::to_string( obj.acid_resist() ) );
115 r.push_back( std::to_string( obj.fire_resist() ) );
116 rows.push_back( r );
117 };
118
119 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
120
121 for( const itype *e : item_controller->all() ) {
122 if( e->armor ) {
123 item obj( e );
124 if( bp == num_bp || obj.covers( bp ) ) {
125 if( obj.has_flag( flag_VARSIZE ) ) {
126 obj.set_flag( "FIT" );
127 }
128 dump( obj );
129 }
130 }
131 }
132
133 } else if( what == "EDIBLE" ) {
134 header = {
135 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
136 };
137 for( const auto &v : vitamin::all() ) {
138 header.push_back( v.second.name() );
139 }
140 auto dump = [&rows]( const item & obj ) {
141 std::vector<std::string> r;
142 r.push_back( obj.tname( 1, false ) );
143 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
144 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
145 r.push_back( std::to_string( obj.type->stack_size ) );
146 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
147 r.push_back( std::to_string( obj.get_comestible()->quench ) );
148 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
149 auto vits = obj.get_comestible()->default_nutrition.vitamins;
150 for( const auto &v : vitamin::all() ) {
151 r.push_back( std::to_string( vits[ v.first ] ) );
152 }
153 rows.push_back( r );
154 };
155
156 for( const itype *e : item_controller->all() ) {
158
159 if( food.is_food() && g->u.can_eat( food ).success() ) {
160 dump( food );
161 }
162 }
163
164 } else if( what == "GUN" ) {
165 header = {
166 "Name", "Ammo", "Volume", "Weight", "Capacity",
167 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
168 "Aim time", "Effective range", "Snapshot range", "Max range"
169 };
170
171 std::set<std::string> locations;
172 for( const itype *e : item_controller->all() ) {
173 if( e->gun ) {
174 std::transform( e->gun->valid_mod_locations.begin(),
175 e->gun->valid_mod_locations.end(),
176 std::inserter( locations, locations.begin() ),
177 []( const std::pair<gunmod_location, int> &q ) {
178 return q.first.name();
179 } );
180 }
181 }
182 for( const auto &e : locations ) {
183 header.push_back( e );
184 }
185
186 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
187 std::vector<std::string> r;
188 r.push_back( obj.tname( 1, false ) );
189 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
190 obj.ammo_types().end(), []( const ammotype & at ) {
191 return at.str();
193 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
194 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
195 r.push_back( std::to_string( obj.ammo_capacity() ) );
196 r.push_back( std::to_string( obj.gun_range() ) );
197 r.push_back( std::to_string( obj.gun_dispersion() ) );
198 r.push_back( std::to_string( obj.gun_recoil() ) );
199 damage_instance damage = obj.gun_damage();
200 r.push_back( std::to_string( damage.total_damage() ) );
201 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
202
203 r.push_back( std::to_string( ranged::gun_engagement_moves( who, obj ) ) );
204
205 for( const auto &e : locations ) {
206 const auto &vml = obj.type->gun->valid_mod_locations;
207 const auto iter = vml.find( e );
208 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
209 }
210 rows.push_back( r );
211 };
212 for( const itype *e : item_controller->all() ) {
213 if( e->gun ) {
214 item gun( e );
215 if( !gun.magazine_integral() ) {
216 gun.put_in( item( gun.magazine_default() ) );
217 }
218 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
219
220 dump( test_npcs[ "S1" ], gun );
221
222 if( gun.type->gun->barrel_length > 0_ml ) {
223 gun.put_in( item( "barrel_small" ) );
224 dump( test_npcs[ "S1" ], gun );
225 }
226 }
227 }
228
229 } else if( what == "RECIPE" ) {
230
231 // optionally filter recipes to include only those using specified skills
232 recipe_subset dict;
233 for( const auto &r : recipe_dict ) {
234 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
235 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
236 return true;
237 }
238 const auto iter = r.second.required_skills.find( skill_id( s ) );
239 return iter != r.second.required_skills.end() && iter->second > 0;
240 } ) ) {
241 dict.include( &r.second );
242 }
243 }
244
245 // only consider skills that are required by at least one recipe
246 std::vector<Skill> sk;
247 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
248 std::back_inserter( sk ), [&dict]( const Skill & s ) {
249 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
250 return r->skill_used == s.ident() ||
251 r->required_skills.find( s.ident() ) != r->required_skills.end();
252 } );
253 } );
254
255 header = { "Result" };
256
257 for( const auto &e : sk ) {
258 header.push_back( e.ident().str() );
259 }
260
261 for( const recipe *e : dict ) {
262 std::vector<std::string> r;
263 r.push_back( e->result_name() );
264 for( const auto &s : sk ) {
265 if( e->skill_used == s.ident() ) {
266 r.push_back( std::to_string( e->difficulty ) );
267 } else {
268 auto iter = e->required_skills.find( s.ident() );
269 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
270 }
271 }
272 rows.push_back( r );
273 }
274
275 } else if( what == "VEHICLE" ) {
276 header = {
277 "Name", "Weight (empty)", "Weight (fueled)",
278 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
279 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
280 };
281 auto dump = [&rows]( const vproto_id & obj ) {
282 vehicle veh_empty( obj, 0, 0 );
283 vehicle veh_fueled( obj, 100, 0 );
284
285 std::vector<std::string> r;
286 r.push_back( veh_empty.name );
287 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
288 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
289 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
290 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
293 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
294 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
295 r.push_back( std::to_string( static_cast<int>( 50 *
296 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
297 rows.push_back( r );
298 };
299 for( auto &e : vehicle_prototype::get_all() ) {
300 dump( e );
301 }
302
303 } else if( what == "VPART" ) {
304 header = {
305 "Name", "Location", "Weight", "Size"
306 };
307 auto dump = [&rows]( const vpart_info & obj ) {
308 std::vector<std::string> r;
309 r.push_back( obj.name() );
310 r.push_back( obj.location );
311 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
312 r.push_back( std::to_string( w ) );
313 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
314 rows.push_back( r );
315 };
316 for( const auto &e : vpart_info::all() ) {
317 dump( e.second );
318 }
319
320 } else {
321 std::cerr << "unknown argument: " << what << std::endl;
322 return false;
323 }
324
325 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
326 return e.empty();
327 } ), rows.end() );
328
329 if( scol >= 0 ) {
330 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
331 const std::vector<std::string> &rhs ) {
332 return localized_compare( lhs[ scol ], rhs[ scol ] );
333 } );
334 }
335
336 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
337
338 switch( mode ) {
339 case dump_mode::TSV:
340 rows.insert( rows.begin(), header );
341 for( const auto &r : rows ) {
342 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
343 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
344 std::cout << r.back() << "\n";
345 }
346 break;
347
348 case dump_mode::HTML:
349 std::cout << "<table>";
350
351 std::cout << "<thead>";
352 std::cout << "<tr>";
353 for( const auto &col : header ) {
354 std::cout << "<th>" << col << "</th>";
355 }
356 std::cout << "</tr>";
357 std::cout << "</thead>";
358
359 std::cout << "<tdata>";
360 for( const auto &r : rows ) {
361 std::cout << "<tr>";
362 for( const auto &col : r ) {
363 std::cout << "<td>" << col << "</td>";
364 }
365 std::cout << "</tr>";
366 }
367 std::cout << "</tdata>";
368
369 std::cout << "</table>";
370 break;
371 }
372
373 return true;
374}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4958
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:995
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:590
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1357
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:695
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1639
void load_core_bn_modfiles()
Load & finalize modlist that consists of single vanilla BN core "mod".
Definition: init.cpp:863
int gun_engagement_moves(const Character &who, const item &gun, int target=0, int start=MAX_RECOIL)
How many moves does it take to aim gun to the target accuracy.
Definition: ranged.cpp:583
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:637
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:231
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157

References vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), flag_VARSIZE(), g, get_body_part_token(), itype::gun, ranged::gun_engagement_moves(), item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, init::load_core_bn_modfiles(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 2712 of file game.cpp.

2713{
2714 return *event_bus_ptr;
2715}
pimpl< event_bus > event_bus_ptr
Definition: game.h:952

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
point  cp = point_zero 
)

open vehicle interaction screen

Definition at line 4984 of file game.cpp.

4985{
4986 if( veh.magic ) {
4987 add_msg( m_info, _( "This is your %s" ), veh.name );
4988 return;
4989 }
4990 auto act = veh_interact::run( veh, c );
4991 if( act ) {
4992 u.moves = 0;
4994 }
4995}
static player_activity run(vehicle &veh, point p)
bool magic
Definition: vehicle.h:1891
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5375 of file game.cpp.

5376{
5377 // if we are driving a vehicle, examine the
5378 // current tile without asking.
5379 const optional_vpart_position vp = m.veh_at( u.pos() );
5380 if( vp && vp->vehicle().player_in_control( u ) ) {
5381 examine( u.pos() );
5382 return;
5383 }
5384
5385 const std::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5386 _( "There is nothing that can be examined nearby." ),
5387 ACTION_EXAMINE, false );
5388 if( !examp_ ) {
5389 return;
5390 }
5391 u.manual_examine = true;
5392 examine( *examp_ );
5393 u.manual_examine = false;
5394}
std::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1042
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:101
void examine()
Definition: game.cpp:5375
bool manual_examine
Definition: player.h:249

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5463 of file game.cpp.

5464{
5465 if( disable_robot( examp ) ) {
5466 return;
5467 }
5468
5469 Creature *c = critter_at( examp );
5470 if( c != nullptr ) {
5471 monster *mon = dynamic_cast<monster *>( c );
5472 if( mon != nullptr ) {
5473 add_msg( _( "There is a %s." ), mon->get_name() );
5474 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5475 if( monexamine::pet_menu( *mon ) ) {
5476 return;
5477 }
5478 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5479 if( monexamine::mech_hack( *mon ) ) {
5480 return;
5481 }
5482 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5483 if( monexamine::pay_bot( *mon ) ) {
5484 return;
5485 }
5486 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5487 if( monexamine::mfriend_menu( *mon ) ) {
5488 return;
5489 }
5490 }
5491 } else if( u.is_mounted() ) {
5492 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5493 }
5494 npc *np = dynamic_cast<npc *>( c );
5495 if( np != nullptr && !u.is_mounted() ) {
5496 if( npc_menu( *np ) ) {
5497 return;
5498 }
5499 } else if( np != nullptr && u.is_mounted() ) {
5500 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5501 }
5502 }
5503
5504 const optional_vpart_position vp = m.veh_at( examp );
5505 if( vp && u.is_mounted() ) {
5506 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5507 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5508 } else {
5509 vp->vehicle().interact_with( examp, vp->part_index() );
5510 return;
5511 }
5512 } else if( vp && !u.is_mounted() ) {
5513 vp->vehicle().interact_with( examp, vp->part_index() );
5514 return;
5515 }
5516
5517 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5518 use_computer( examp );
5519 return;
5520 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5521 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5522 }
5523 const furn_t &xfurn_t = m.furn( examp ).obj();
5524 const ter_t &xter_t = m.ter( examp ).obj();
5525
5526 const tripoint player_pos = u.pos();
5527
5528 if( m.has_furn( examp ) && !u.is_mounted() ) {
5529 xfurn_t.examine( u, examp );
5530 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5531 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5532 } else {
5533 if( !u.is_mounted() ) {
5534 xter_t.examine( u, examp );
5535 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5536 xter_t.examine( u, examp );
5537 } else {
5538 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5539 }
5540 }
5541
5542 // Did the player get moved? Bail out if so; our examp probably
5543 // isn't valid anymore.
5544 if( player_pos != u.pos() ) {
5545 return;
5546 }
5547
5548 bool none = true;
5549 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5550 none = false;
5551 }
5552
5553 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5554 iexamine::trap( u, examp );
5555 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5556 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5557 }
5558
5559 // In case of teleport trap or somesuch
5560 if( player_pos != u.pos() ) {
5561 return;
5562 }
5563
5564 // Feedback for fire lasting time, this can be judged while mounted
5565 const std::string fire_fuel = get_fire_fuel_string( examp );
5566 if( !fire_fuel.empty() ) {
5567 add_msg( fire_fuel );
5568 }
5569
5570 if( m.has_flag( "SEALED", examp ) ) {
5571 if( none ) {
5572 if( m.has_flag( "UNSTABLE", examp ) ) {
5573 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5574 } else {
5575 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5576 }
5577 }
5578 } else {
5579 //examp has no traps, is a container and doesn't have a special examination function
5580 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5581 m.has_flag( "CONTAINER", examp ) && none ) {
5582 add_msg( _( "It is empty." ) );
5583 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5584 xfurn_t.examine == &iexamine::fireplace ) ||
5585 xfurn_t.examine == &iexamine::workbench ||
5586 xfurn_t.examine == &iexamine::transform ) {
5587 return;
5588 } else {
5590 if( !u.is_mounted() ) {
5591 pickup::pick_up( examp, 0 );
5592 }
5593 }
5594 }
5595}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1590
@ A_FRIENDLY
Definition: creature.h:169
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4495
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:8624
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5266
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1402
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5230
ter_id ter(const tripoint &p) const
Definition: map.cpp:1557
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1049
std::string get_name() const override
Definition: monster.cpp:488
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5396
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2916
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6194
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:252
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3815
bool pet_menu(monster &z)
Definition: monexamine.cpp:67
bool mech_hack(monster &z)
Definition: monexamine.cpp:428
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:502
bool pay_bot(monster &z)
Definition: monexamine.cpp:461
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:574
iexamine_function examine
Definition: mapdata.h:402
Definition: mapdata.h:461
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::transform(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 51 of file descriptions.cpp.

52{
54 const int top = 3;
55 int width = 0;
56 catacurses::window w_head;
57 catacurses::window w_main;
58 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
59 const int left = 0;
60 const int right = TERMX;
61 const int bottom = TERMY;
62 width = right - left;
63 const int height = bottom - top;
64 w_head = catacurses::newwin( top, TERMX, point_zero );
65 w_main = catacurses::newwin( height, width, point( left, top ) );
66 ui.position( point_zero, point( TERMX, TERMY ) );
67 } );
68 ui.mark_resize();
69
70 // Default to critter (if any), furniture (if any), then terrain.
72 if( seen_critter( *this, p ) != nullptr ) {
74 } else if( get_map().has_furn( p ) ) {
76 }
77
78 std::string action;
79 input_context ctxt( "EXTENDED_DESCRIPTION" );
80 ctxt.register_action( "CREATURE" );
81 ctxt.register_action( "FURNITURE" );
82 ctxt.register_action( "TERRAIN" );
83 ctxt.register_action( "CONFIRM" );
84 ctxt.register_action( "QUIT" );
85 ctxt.register_action( "HELP_KEYBINDINGS" );
86
87 ui.on_redraw( [&]( const ui_adaptor & ) {
88 werase( w_head );
90 _( "[%s] describe creatures, [%s] describe furniture, "
91 "[%s] describe terrain, [%s] close." ),
92 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
93 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
94
95 // Set up line drawings
96 for( int i = 0; i < TERMX; i++ ) {
97 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
98 }
99
100 wnoutrefresh( w_head );
101
102 std::string desc;
103 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
104 switch( cur_target ) {
106 const Creature *critter = seen_critter( *this, p );
107 if( critter != nullptr ) {
108 desc = critter->extended_description();
109 } else {
110 desc = _( "You do not see any creature here." );
111 }
112 }
113 break;
115 if( !u.sees( p ) || !m.has_furn( p ) ) {
116 desc = _( "You do not see any furniture here." );
117 } else {
118 const furn_id fid = m.furn( p );
119 if( display_mod_source ) {
120 const std::string mod_src = enumerate_as_string( fid->src.begin(),
121 fid->src.end(), []( const std::pair<furn_str_id, mod_id> &source ) {
122 return string_format( "'%s'", source.second->name() );
124 desc = string_format( _( "Origin: %s\n" ), mod_src );
125 }
126 if( display_object_ids ) {
127 desc += colorize( string_format( "[%s]\n", fid.id() ), c_light_blue );
128 }
129 desc += fid.obj().extended_description();
130 }
131 break;
133 if( !u.sees( p ) ) {
134 desc = _( "You can't see the terrain here." );
135 } else {
136 const ter_id tid = m.ter( p );
137 if( display_mod_source ) {
138 const std::string mod_src = enumerate_as_string( tid->src.begin(),
139 tid->src.end(), []( const std::pair<ter_str_id, mod_id> &source ) {
140 return string_format( "'%s'", source.second->name() );
142 desc = string_format( _( "Origin: %s\n" ), mod_src );
143 }
144 if( display_object_ids ) {
145 desc += colorize( string_format( "[%s]\n", tid.id() ), c_light_blue );
146 }
147 desc += tid.obj().extended_description();
148 }
149 break;
150 }
151
152 std::string signage = m.get_signage( p );
153 if( !signage.empty() ) {
154 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
155 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
156 signage );
157 }
158
159 werase( w_main );
160 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
161 wnoutrefresh( w_main );
162 } );
163
164 do {
166 action = ctxt.handle_input();
167 if( action == "CREATURE" ) {
168 cur_target = description_target::creature;
169 } else if( action == "FURNITURE" ) {
171 } else if( action == "TERRAIN" ) {
172 cur_target = description_target::terrain;
173 }
174 } while( action != "CONFIRM" && action != "QUIT" );
175}
bool display_object_ids
Display internal IDs for items, furniture, terrain and monsters.
bool display_mod_source
Display mod source for items, furniture, terrain and monsters.
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:147
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
std::string get_signage(const tripoint &p) const
Definition: map.cpp:4092
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, point begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::vector< std::pair< furn_str_id, mod_id > > src
Definition: mapdata.h:498
std::string extended_description() const
std::vector< std::pair< ter_str_id, mod_id > > src
Definition: mapdata.h:463

References _, action, arrow, c_light_blue, c_light_gray, c_white, colorize(), creature, display_mod_source, display_object_ids, enumerate_as_string(), map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), int_id< T >::id(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), ter_t::src, furn_t::src, string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 6919 of file game.cpp.

6920{
6921 std::map<std::string, map_item_stack> temp_items;
6922 std::vector<map_item_stack> ret;
6923 std::vector<std::string> item_order;
6924
6925 if( u.is_blind() ) {
6926 return ret;
6927 }
6928
6929 int range = fov_3d ? ( fov_3d_z_range * 2 ) + 1 : 1;
6930 int center_z = u.pos().z;
6931
6932 for( int i = 1; i <= range; i++ ) {
6933 int z = i % 2 ? center_z - i / 2 : center_z + i / 2;
6934 for( auto &points_p_it : closest_points_first( {u.pos().xy(), z}, iRadius ) ) {
6935 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
6936 u.sees( points_p_it ) &&
6937 m.sees_some_items( points_p_it, u ) ) {
6938
6939 for( auto &elem : m.i_at( points_p_it ) ) {
6940 const std::string name = elem.tname();
6941 const tripoint relative_pos = points_p_it - u.pos();
6942
6943 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
6944 item_order.push_back( name );
6945 temp_items[name] = map_item_stack( &elem, relative_pos );
6946 } else {
6947 temp_items[name].add_at_pos( &elem, relative_pos );
6948 }
6949 }
6950 }
6951 }
6952 }
6953
6954 for( auto &elem : item_order ) {
6955 ret.push_back( temp_items[elem] );
6956 }
6957
6958 return ret;
6959}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool fov_3d
3D FoV enabled/disabled.
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6253
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), fov_3d, fov_3d_z_range, map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), u, and tripoint::z.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1874 of file game.cpp.

1875{
1876 return overmap_buffer.find_npc( id ).get();
1877}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

std::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10412 of file game.cpp.

10414{
10415 const int omtilesz = SEEX * 2;
10416 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10417 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10418 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10419
10420 // Try to find the stairs.
10421 std::optional<tripoint> stairs;
10422 int best = INT_MAX;
10423 const int movez = z_after - get_levz();
10424 const bool going_down_1 = movez == -1;
10425 const bool going_up_1 = movez == 1;
10426 // If there are stairs on the same x and y as we currently are, use those
10427 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
10428 stairs.emplace( u.pos() + tripoint_below );
10429 }
10430 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
10431 stairs.emplace( u.pos() + tripoint_above );
10432 }
10433 // We did not find stairs directly above or below, so search the map for them
10434 if( !stairs.has_value() ) {
10435 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
10436 if( rl_dist( u.pos(), dest ) <= best &&
10437 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
10438 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
10439 mp.ter( dest ) == t_manhole_cover ) ) ||
10440 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
10441 stairs.emplace( dest );
10442 best = rl_dist( u.pos(), dest );
10443 }
10444 }
10445 }
10446
10447 if( stairs.has_value() ) {
10448 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
10449 npc *guy = dynamic_cast<npc *>( blocking_creature );
10450 monster *mon = dynamic_cast<monster *>( blocking_creature );
10451 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
10452 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
10453 std::string cr_name = blocking_creature->get_name();
10454 std::string msg;
10455 if( guy ) {
10456 //~ %s is the name of hostile NPC
10457 msg = string_format( _( "%s is in the way!" ), cr_name );
10458 } else {
10459 //~ %s is some monster
10460 msg = string_format( _( "There's a %s in the way!" ), cr_name );
10461 }
10462
10463 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
10464 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
10465 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
10466 add_msg( msg );
10467 return std::nullopt;
10468 }
10469 }
10470 return stairs;
10471 }
10472
10473 // No stairs found! Try to make some
10474 rope_ladder = false;
10475 stairs.emplace( u.pos() );
10476 stairs->z = z_after;
10477 // Check the destination area for lava.
10478 if( mp.ter( *stairs ) == t_lava ) {
10479 if( movez < 0 &&
10480 !query_yn(
10481 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
10482 return std::nullopt;
10483 } else if( movez > 0 &&
10484 !query_yn(
10485 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
10486 return std::nullopt;
10487 }
10488
10489 return stairs;
10490 }
10491
10492 if( movez > 0 ) {
10493 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
10494 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
10495 return std::nullopt;
10496 }
10497 }
10498 // Manhole covers need this to work
10499 // Maybe require manhole cover here and fail otherwise?
10500 return stairs;
10501 }
10502
10503 if( mp.impassable( *stairs ) ) {
10504 popup( _( "Halfway down, the way down becomes blocked off." ) );
10505 return std::nullopt;
10506 }
10507
10508 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
10509 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
10510 rope_ladder = true;
10511 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
10512 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
10513 } else {
10514 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
10515 }
10516 } else {
10517 return std::nullopt;
10518 }
10519 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
10520 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
10521 if( u.has_trait( trait_VINES2 ) ) {
10522 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
10523 rope_ladder = true;
10524 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
10525 u.mod_pain( 5 );
10526 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
10527 u.mod_stored_nutr( 10 );
10528 u.mod_thirst( 10 );
10529 } else {
10530 add_msg( _( "You gingerly descend using your vines." ) );
10531 }
10532 } else {
10533 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
10534 rope_ladder = true;
10535 u.mod_stored_nutr( 10 );
10536 u.mod_thirst( 10 );
10537 }
10538 } else {
10539 return std::nullopt;
10540 }
10541 } else if( u.has_amount( itype_grapnel, 1 ) ) {
10542 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
10543 rope_ladder = true;
10545 } else {
10546 return std::nullopt;
10547 }
10548 } else if( u.has_amount( itype_rope_30, 1 ) ) {
10549 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
10550 rope_ladder = true;
10552 } else {
10553 return std::nullopt;
10554 }
10555 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
10556 return std::nullopt;
10557 }
10558
10559 return stairs;
10560}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: character.cpp:754
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8374
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9601
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4419
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4309
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3331
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8372
bool impassable(const tripoint &p) const
Definition: map.cpp:1854
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8701
bool is_enemy() const
Definition: npc.cpp:2059
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static std::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:9948
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:722
ter_id t_lava
Definition: mapdata.cpp:697
ter_id t_elevator
Definition: mapdata.cpp:725
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr tripoint tripoint_below
Definition: point.h:281
static constexpr tripoint tripoint_above
Definition: point.h:280

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, Character::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, and Character::use_amount().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false 
)

Flings the input creature in the given direction.

Definition at line 9751 of file game.cpp.

9752{
9753 if( c == nullptr ) {
9754 debugmsg( "game::fling_creature invoked on null target" );
9755 return;
9756 }
9757
9758 if( c->is_dead_state() ) {
9759 // Flinging a corpse causes problems, don't enable without testing
9760 return;
9761 }
9762
9763 if( c->is_hallucination() ) {
9764 // Don't fling hallucinations
9765 return;
9766 }
9767
9768 bool thru = true;
9769 const bool is_u = ( c == &u );
9770 // Don't animate critters getting bashed if animations are off
9771 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
9772
9773 player *p = dynamic_cast<player *>( c );
9774
9775 tileray tdir( dir );
9776 int range = flvel / 10;
9777 tripoint pt = c->pos();
9778 tripoint prev_point = pt;
9779 bool force_next = false;
9780 tripoint next_forced;
9781 while( range > 0 ) {
9782 c->set_underwater( false );
9783 // TODO: Check whenever it is actually in the viewport
9784 // or maybe even just redraw the changed tiles
9785 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
9786 if( force_next ) {
9787 pt = next_forced;
9788 force_next = false;
9789 } else {
9790 tdir.advance();
9791 pt.x = c->posx() + tdir.dx();
9792 pt.y = c->posy() + tdir.dy();
9793 }
9794 float force = 0;
9795
9796 if( m.obstructed_by_vehicle_rotation( prev_point, pt ) ) {
9797 //We process the intervening tile on this iteration and then the current tile on the next
9798 next_forced = pt;
9799 force_next = true;
9800 if( one_in( 2 ) ) {
9801 pt.x = prev_point.x;
9802 } else {
9803 pt.y = prev_point.y;
9804 }
9805 }
9806
9807
9808 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
9809 monster &critter = *mon_ptr;
9810 // Approximate critter's "stopping power" with its max hp
9811 force = std::min<float>( 1.5f * critter.type->hp, flvel );
9812 const int damage = rng( force, force * 2.0f ) / 6;
9813 c->impact( damage, pt );
9814 // Multiply zed damage by 6 because no body parts
9815 const int zed_damage = std::max( 0,
9816 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
9817 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
9818 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
9819 critter.check_dead_state();
9820 if( !critter.is_dead() ) {
9821 thru = false;
9822 }
9823 } else if( m.impassable( pt ) ) {
9824 if( !m.veh_at( pt ).obstacle_at_part() ) {
9825 force = std::min<float>( m.bash_strength( pt ), flvel );
9826 } else {
9827 // No good way of limiting force here
9828 // Keep it 1 less than maximum to make the impact hurt
9829 // but to keep the target flying after it
9830 force = flvel - 1;
9831 }
9832 const int damage = rng( force, force * 2.0f ) / 9;
9833 c->impact( damage, pt );
9834 if( m.is_bashable( pt ) ) {
9835 // Only go through if we successfully make the tile passable
9836 m.bash( pt, flvel );
9837 thru = m.passable( pt );
9838 } else {
9839 thru = false;
9840 }
9841 }
9842
9843 // If the critter dies during flinging, moving it around causes debugmsgs
9844 if( c->is_dead_state() ) {
9845 return;
9846 }
9847
9848 flvel -= force;
9849 if( thru ) {
9850 if( p != nullptr ) {
9851 if( p->in_vehicle ) {
9852 m.unboard_vehicle( p->pos() );
9853 }
9854 // If we're flinging the player around, make sure the map stays centered on them.
9855 if( is_u ) {
9856 update_map( pt.x, pt.y );
9857 } else {
9858 p->setpos( pt );
9859 }
9860 } else if( !critter_at( pt ) ) {
9861 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
9862 // Just don't setpos if it happens - next iteration will do so
9863 // or the monster will stop a tile before the unpassable one
9864 c->setpos( pt );
9865 }
9866 } else {
9867 // Don't zero flvel - count this as slamming both the obstacle and the ground
9868 // although at lower velocity
9869 break;
9870 }
9871 //Vehicle wall tiles don't count for range
9872 if( !force_next ) {
9873 range--;
9874 }
9875 prev_point = pt;
9876 if( animate && ( seen || u.sees( *c ) ) ) {
9881 }
9882 }
9883
9884 // Fall down to the ground - always on the last reached tile
9885 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
9886 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
9887 // Didn't smash into a wall or a floor so only take the fall damage
9888 if( thru && trap_under_creature == tr_ledge ) {
9889 m.creature_on_trap( *c, false );
9890 } else {
9891 // Fall on ground
9892 int force = rng( flvel, flvel * 2 ) / 9;
9893 if( controlled ) {
9894 force = std::max( force / 2 - 5, 0 );
9895 }
9896 if( force > 0 ) {
9897 int dmg = c->impact( force, c->pos() );
9898 // TODO: Make landing damage the floor
9899 m.bash( c->pos(), dmg / 4, false, false, false );
9900 }
9901 // Always apply traps to creature i.e. bear traps, tele traps etc.
9902 m.creature_on_trap( *c, false );
9903 }
9904 } else {
9905 c->set_underwater( true );
9906 if( is_u ) {
9907 if( controlled ) {
9908 add_msg( _( "You dive into water." ) );
9909 } else {
9910 add_msg( m_warning, _( "You fall into water." ) );
9911 }
9912 }
9913 }
9914}
void setpos(const tripoint &p) override
Definition: character.h:811
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1872
point update_map(player &p)
Definition: game.cpp:10639
void pump_events()
Resize & refresh if necessary, process all pending window events, and ignore keypresses.
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2536
bool obstructed_by_vehicle_rotation(const tripoint &from, const tripoint &to) const
Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.
Definition: map.cpp:6588
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3617
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1140
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2501
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8578
bool passable(const tripoint &p) const
Definition: map.cpp:1859
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1888
bool is_dead() const
Definition: monster.cpp:2780
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1669
std::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2494
Definition: player.h:84
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Redraw all invalidated windows without invalidating the top window.
Definition: ui_manager.cpp:394
int hp
Definition: mtype.h:270
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:137
int x
Definition: point.h:136

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, inp_mngr, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::obstructed_by_vehicle_rotation(), one_in(), map::passable(), Character::pos(), input_manager::pump_events(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 4997 of file game.cpp.

4998{
4999 const auto valid_location = [&]( const tripoint & p ) {
5000 return g->is_empty( p );
5001 };
5002 const auto get_random_point = [&]() -> tripoint {
5003 if( auto pos = random_point( m.points_in_radius( p, 2 ), valid_location ) )
5004 {
5005 return p * 2 - ( *pos );
5006 } else
5007 {
5008 return p;
5009 }
5010 };
5011
5012 const std::string &door_name = door_type.obj().name();
5013 const tripoint kbp = get_random_point();
5014
5015 // can't pushback any creatures/items anywhere, that means the door can't close.
5016 const bool cannot_push = kbp == p;
5017 const bool can_see = u.sees( p );
5018
5019 player *npc_or_player = critter_at<player>( p, false );
5020 if( npc_or_player != nullptr ) {
5021 if( bash_dmg <= 0 ) {
5022 return false;
5023 }
5024 if( npc_or_player->is_npc() && can_see ) {
5025 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5026 } else if( npc_or_player->is_player() ) {
5027 add_msg( m_bad, _( "The %s hits you." ), door_name );
5028 }
5029 if( npc_or_player->activity ) {
5030 npc_or_player->cancel_activity();
5031 }
5032 // TODO: make the npc angry?
5033 npc_or_player->hitall( bash_dmg, 0, nullptr );
5034 if( cannot_push ) {
5035 return false;
5036 }
5037 // TODO implement who was closing the door and replace nullptr
5038 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5039 // TODO: perhaps damage/destroy the gate
5040 // if the npc was really big?
5041 }
5042 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5043 monster &critter = *mon_ptr;
5044 if( bash_dmg <= 0 ) {
5045 return false;
5046 }
5047 if( can_see ) {
5048 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5049 }
5050 if( critter.type->size <= MS_SMALL ) {
5051 critter.die_in_explosion( nullptr );
5052 } else {
5053 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5054 critter.check_dead_state();
5055 }
5056 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5057 // big critters simply prevent the gate from closing
5058 // TODO: perhaps damage/destroy the gate
5059 // if the critter was really big?
5060 return false;
5061 }
5062 if( !critter.is_dead() ) {
5063 // Still alive? Move the critter away so the door can close
5064 if( cannot_push ) {
5065 return false;
5066 }
5067 // TODO implement who was closing the door and replace nullptr
5068 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1, nullptr );
5069 if( critter_at( p ) ) {
5070 return false;
5071 }
5072 }
5073 }
5074 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5075 if( bash_dmg <= 0 ) {
5076 return false;
5077 }
5078 vp->vehicle().damage( vp->part_index(), bash_dmg );
5079 if( m.veh_at( p ) ) {
5080 // Check again in case all parts at the door tile
5081 // have been destroyed, if there is still a vehicle
5082 // there, the door can not be closed
5083 return false;
5084 }
5085 }
5086 if( bash_dmg < 0 && !m.i_at( p ).empty() ) {
5087 return false;
5088 }
5089 if( bash_dmg == 0 ) {
5090 for( auto &elem : m.i_at( p ) ) {
5091 if( elem.made_of( LIQUID ) ) {
5092 // Liquids are OK, will be destroyed later
5093 continue;
5094 } else if( elem.volume() < 250_ml ) {
5095 // Dito for small items, will be moved away
5096 continue;
5097 }
5098 // Everything else prevents the door from closing
5099 return false;
5100 }
5101 }
5102
5103 m.ter_set( p, door_type );
5104 if( m.has_flag( "NOITEM", p ) ) {
5105 map_stack items = m.i_at( p );
5106 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5107 if( it->made_of( LIQUID ) ) {
5108 it = items.erase( it );
5109 continue;
5110 }
5111 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5112 if( can_see ) {
5113 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5114 } else {
5115 add_msg( m_warning, _( "Something shatters!" ) );
5116 }
5117 it = items.erase( it );
5118 continue;
5119 }
5120 if( cannot_push ) {
5121 return false;
5122 }
5123 m.add_item_or_charges( kbp, *it );
5124 it = items.erase( it );
5125 }
5126 }
5127 return true;
5128}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8651
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult, Creature *source)
Definition: game.cpp:4236
iterator erase(const_iterator it) override
Definition: map.cpp:153
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1698
void die_in_explosion(Creature *source)
Definition: monster.cpp:1683
bool is_npc() const override
Definition: player.h:103
bool is_player() const override
Definition: player.h:93
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
std::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:513
m_size size
Definition: mtype.h:262

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::empty(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, and map::veh_at().

◆ gametype()

special_game_type game::gametype ( ) const

Definition at line 535 of file game.cpp.

536{
538}

References gamemode, and NONE.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 11987 of file game.cpp.

11988{
11989 for( Creature &critter : all_creatures() ) {
11990 if( pred( critter ) ) {
11991 return &critter;
11992 }
11993 }
11994 return nullptr;
11995}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 11897 of file game.cpp.

11899{
11900 std::vector<Creature *> result;
11901 for( Creature &critter : all_creatures() ) {
11902 if( pred( critter ) ) {
11903 result.push_back( &critter );
11904 }
11905 }
11906 return result;
11907}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 11877 of file game.cpp.

11878{
11879 // The player is located in the middle submap of the map.
11881 const tripoint pos_om = sm_to_om_copy( sm );
11882 // TODO: fix point types
11883 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
11884}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8382
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(point p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8708 of file game.cpp.

8709{
8710 std::vector<std::string> harmful_stuff;
8711 const auto fields_here = m.field_at( u.pos() );
8712 for( const auto &e : m.field_at( dest_loc ) ) {
8713 // warn before moving into a dangerous field except when already standing within a similar field
8714 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
8715 harmful_stuff.push_back( e.second.name() );
8716 }
8717 }
8718
8719 if( !u.is_blind() ) {
8720 const trap &tr = m.tr_at( dest_loc );
8721 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
8722 true ) );
8723 // HACK: Hack for now, later ledge should stop being a trap
8724 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
8725 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
8726 if( !boardable ) {
8727 harmful_stuff.emplace_back( tr.name() );
8728 }
8729 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
8730 harmful_stuff.emplace_back( tr.name() );
8731 }
8732
8733 static const std::set< body_part > sharp_bps = {
8736 };
8737
8738 const auto sharp_bp_check = [this]( body_part bp ) {
8739 return character_funcs::is_bp_immune_to( u, bp, { DT_CUT, 10 } );
8740 };
8741
8742 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
8743 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
8744 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
8745 harmful_stuff.emplace_back( m.name( dest_loc ) );
8746 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
8747 m.veh_at( dest_loc ) ) &&
8748 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
8749 harmful_stuff.emplace_back( m.name( dest_loc ) );
8750 }
8751
8752 }
8753
8754 return harmful_stuff;
8755}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:264
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6841
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:198
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5392
bool has_zlevels() const
Definition: map.h:1631
@ DT_CUT
Definition: damage.h:25
bool is_bp_immune_to(const Character &who, body_part bp, damage_unit dam)
Check if character's body part is immune to given damage.
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), character_funcs::is_bp_immune_to(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3594 of file game.cpp.

3595{
3596 // We're going to get the contiguous fishable terrain starting at
3597 // the provided fishing location (e.g. where a line was cast or a fish
3598 // trap was set), and then check whether or not fishable monsters are
3599 // actually in those locations. This will help us ensure that we're
3600 // getting our fish from the location that we're ACTUALLY fishing,
3601 // rather than just somewhere in the vicinity.
3602
3603 std::unordered_set<tripoint> visited;
3604
3605 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3606 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3607
3608 const inclusive_cuboid<tripoint> fishing_boundaries(
3609 fishing_boundary_min, fishing_boundary_max );
3610
3611 const auto get_fishable_terrain = [&]( tripoint starting_point,
3612 std::unordered_set<tripoint> &fishable_terrain ) {
3613 std::queue<tripoint> to_check;
3614 to_check.push( starting_point );
3615 while( !to_check.empty() ) {
3616 const tripoint current_point = to_check.front();
3617 to_check.pop();
3618
3619 // We've been here before, so bail.
3620 if( visited.find( current_point ) != visited.end() ) {
3621 continue;
3622 }
3623
3624 // This point is out of bounds, so bail.
3625 if( !fishing_boundaries.contains( current_point ) ) {
3626 continue;
3627 }
3628
3629 // Mark this point as visited.
3630 visited.emplace( current_point );
3631
3632 if( m.has_flag( "FISHABLE", current_point ) ) {
3633 fishable_terrain.emplace( current_point );
3634 to_check.push( current_point + point_south );
3635 to_check.push( current_point + point_north );
3636 to_check.push( current_point + point_east );
3637 to_check.push( current_point + point_west );
3638 }
3639 }
3640 return;
3641 };
3642
3643 // Starting at the provided location, get our fishable terrain
3644 // and populate a set with those locations which we'll then use
3645 // to determine if any fishable monsters are in those locations.
3646 std::unordered_set<tripoint> fishable_points;
3647 get_fishable_terrain( fish_pos, fishable_points );
3648
3649 return fishable_points;
3650}
static constexpr point point_west
Definition: point.h:268
static constexpr point point_south
Definition: point.h:266
static constexpr point point_north
Definition: point.h:262
static constexpr point point_east
Definition: point.h:264

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 3652 of file game.cpp.

3654{
3655 std::vector<monster *> unique_fish;
3656 for( monster &critter : all_monsters() ) {
3657 // If it is fishable...
3658 if( critter.has_flag( MF_FISHABLE ) ) {
3659 const tripoint critter_pos = critter.pos();
3660 // ...and it is in a fishable location.
3661 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
3662 unique_fish.push_back( &critter );
3663 }
3664 }
3665 }
3666
3667 return unique_fish;
3668}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 1971 of file game.cpp.

1972{
1973 return follower_ids;
1974}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 881 of file game.cpp.

882{
883 return *kill_tracker_ptr;
884}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 11862 of file game.cpp.

11863{
11864 return m.get_abs_sub().x;
11865}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 11867 of file game.cpp.

11868{
11869 return m.get_abs_sub().y;
11870}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7095 of file game.cpp.

7096{
7097 return moves_since_last_save;
7098}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 11909 of file game.cpp.

11910{
11911 std::vector<npc *> result;
11912 for( npc &guy : all_npcs() ) {
11913 if( pred( guy ) ) {
11914 result.push_back( &guy );
11915 }
11916 }
11917 return result;
11918}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 11997 of file game.cpp.

11998{
11999 return get_world_base_save_path() + "/" + base64_encode( get_avatar().get_save_id() );
12000}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12002
friend avatar & get_avatar()
Definition: avatar.cpp:104

References base64_encode(), get_avatar, and get_world_base_save_path().

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 245 of file handle_action.cpp.

246{
247 input_context ctxt;
248 if( uquit == QUIT_WATCH ) {
249 ctxt = input_context( "DEFAULTMODE" );
250 ctxt.set_iso( true );
251 // The list of allowed actions in death-cam mode in game::handle_action
252 // *INDENT-OFF*
253 for( const action_id id : {
266 } ) {
267 ctxt.register_action( action_ident( id ) );
268 }
269 // *INDENT-ON*
270 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
271 } else {
273 }
274
276
277 user_turn current_turn;
278
279
280 // Checking early if we will need to handle animations
281 // If we do not need to handle animations that will not change as long as the user has not selected an action
282 // and we can handle it like we are not animating.
283 weather_printable wPrint;
284 bool animate_weather = false;
285 bool animate_sct = false;
286 bool do_animations = [&]() {
287 if( get_option<bool>( "ANIMATIONS" ) ) {
288 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
289
290 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
291 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
292
293#if defined(TILES)
294 // Always animate, minimap and terrain may have animations to run
295 return true;
296#else
297 // Otherwise we need to see if we actually should animate.
298 // Minimap and Terrain never animate in !TILES
299 return animate_weather || animate_sct || uquit == QUIT_WATCH;
300#endif
301 }
302 return false;
303 }
304 ();
305
306 if( do_animations ) {
307 ctxt.set_timeout( 125 );
308
310 make_shared_fast<game::draw_callback_t>( [&]() {
311 if( animate_weather ) {
312 draw_weather( wPrint );
313 }
314 if( animate_sct ) {
315 draw_sct();
316 }
317 } );
318 add_draw_callback( animation_cb );
319 invalidate_main_ui_adaptor(); // We want to redraw at least once.
320
321 do {
322 if( animate_weather ) {
324 generate_weather_anim_frame( get_weather().weather_id, wPrint );
325 }
326 // don't bother calculating SCT if we won't show it
327 if( animate_sct ) {
329
331
332 //Check for creatures on all drawing positions and offset if necessary
333 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
334 const direction oCurDir = iter->getDirecton();
335 const int width = utf8_width( iter->getText() );
336 for( int i = 0; i < width; ++i ) {
337 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
338 const Creature *critter = critter_at( tmp, true );
339
340 if( critter != nullptr && u.sees( *critter ) ) {
341 i = -1;
342 int iPos = iter->getStep() + iter->getStepOffset();
343 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
344 if( iter2->getDirecton() == oCurDir &&
345 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
346 if( iter2->getType() == "hp" ) {
347 iter2->advanceStepOffset();
348 }
349
350 iter2->advanceStepOffset();
351 iPos = iter2->getStep() + iter2->getStepOffset();
352 }
353 }
354 }
355 }
356 }
357
358 // Stop animation when done
359 animate_sct = !SCT.vSCT.empty();
360 }
361 // We don't cache these checks as their result may change after 1st redraw
363 // TODO: we redraw *everything* just to animate a couple blinking dots
364 // on the minimap or a few tiles.
365 // This is far from ideal, and can probably be done much cheaper
366 // (update only part of the screen? draw static parts into a texture?)
368 }
369
370 std::unique_ptr<static_popup> deathcam_msg_popup;
371 if( uquit == QUIT_WATCH ) {
372 deathcam_msg_popup = std::make_unique<static_popup>();
373 deathcam_msg_popup
374 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
375 .on_top( true );
376 }
377
379 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
380 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
381 ctxt.reset_timeout();
382 } else {
385 SCT.vSCT.clear();
386
387 ctxt.set_timeout( 125 );
388 while( handle_mouseview( ctxt, action ) ) {
389 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
390 break;
391 }
392 }
393 ctxt.reset_timeout();
394 }
395
396 return ctxt;
397}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:68
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:18
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:73
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:85
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:89
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:255
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:79
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:71
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:83
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:81
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:115
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:77
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:87
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:75
bool terrain_requires_animation()
Definition: animation.cpp:1204
bool minimap_requires_animation()
Definition: animation.cpp:1195
void draw_sct()
Definition: animation.cpp:865
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:824
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3007
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2002
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1452
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:750
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:672
void set_iso(bool mode=true)
Definition: input.cpp:1423
void reset_timeout()
Definition: input.cpp:1457
std::vector< cSCT > vSCT
Definition: output.h:916
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2102
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1783 of file game.cpp.

1784{
1785 return seed;
1786}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7100 of file game.cpp.

7101{
7102 return user_action_counter;
7103}

References user_action_counter.

◆ get_veh_dir_indicator_location()

std::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3262 of file game.cpp.

3263{
3264 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3265 return std::nullopt;
3266 }
3267 const optional_vpart_position vp = m.veh_at( u.pos() );
3268 if( !vp ) {
3269 return std::nullopt;
3270 }
3271 vehicle *const veh = &vp->vehicle();
3272 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3273 float r = 10.0;
3274 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3275}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12002 of file game.cpp.

12003{
12004 if( world_generator->active_world == nullptr ) {
12005 return PATH_INFO::savedir();
12006 }
12007 return world_generator->active_world->folder_path();
12008}
std::string savedir()
Definition: path_info.cpp:246

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), save_factions_missions_npcs(), and setup().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7086 of file game.cpp.

7087{
7088#if defined(TILES)
7089 return tileset_zoom;
7090#else
7091 return DEFAULT_TILESET_ZOOM;
7092#endif
7093}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 9511 of file game.cpp.

9512{
9513 // Furniture: pull, push, or standing still and nudging object around.
9514 // Can push furniture out of reach.
9515 tripoint fpos = u.pos() + u.grab_point;
9516 // supposed position of grabbed furniture
9517 if( !m.has_furn( fpos ) ) {
9518 // Where did it go? We're grabbing thin air so reset.
9519 add_msg( m_info, _( "No furniture at grabbed point." ) );
9520 u.grab( OBJECT_NONE );
9521 return false;
9522 }
9523
9524 const bool pushing_furniture = dp == u.grab_point;
9525 const bool pulling_furniture = dp == -u.grab_point;
9526 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
9527
9528 tripoint fdest = fpos + dp; // intended destination of furniture.
9529 // Check floor: floorless tiles don't need to be flat and have no traps
9530 const bool has_floor = m.has_floor( fdest );
9531 // Unfortunately, game::is_empty fails for tiles we're standing on,
9532 // which will forbid pulling, so:
9533 const bool canmove = (
9534 m.passable( fdest ) &&
9535 critter_at<npc>( fdest ) == nullptr &&
9536 critter_at<monster>( fdest ) == nullptr &&
9537 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
9538 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
9539 !m.has_furn( fdest ) &&
9540 !m.veh_at( fdest ) &&
9541 ( !has_floor || m.tr_at( fdest ).is_null() )
9542 );
9543
9544 const furn_t furntype = m.furn( fpos ).obj();
9545 const int src_items = m.i_at( fpos ).size();
9546 const int dst_items = m.i_at( fdest ).size();
9547
9548 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
9549 [&]( item & liquid_item ) {
9550 return liquid_item.made_of( LIQUID );
9551 } );
9552
9553 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
9554 !m.has_flag( "SWIMMABLE", fdest ) &&
9555 !m.has_flag( "DESTROY_ITEM", fdest );
9556
9557 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
9558 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
9559 m.furn( fpos ).obj().has_flag( "SEALED" );
9560
9561 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
9562 time_duration fire_age = m.get_field_age( fpos, fd_fire );
9563
9564 int str_req = furntype.move_str_req;
9565 // Factor in weight of items contained in the furniture.
9566 units::mass furniture_contents_weight = 0_gram;
9567 for( auto &contained_item : m.i_at( fpos ) ) {
9568 furniture_contents_weight += contained_item.weight();
9569 }
9570 str_req += furniture_contents_weight / 4_kilogram;
9571 if( !canmove ) {
9572 // TODO: What is something?
9573 add_msg( _( "The %s collides with something." ), furntype.name() );
9574 u.moves -= 50;
9575 return true;
9576 ///\EFFECT_STR determines ability to drag furniture
9577 } else if( str_req > u.get_str() &&
9578 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
9579 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
9580 furntype.name() );
9581 u.moves -= 100;
9582 u.mod_pain( 1 ); // Hurt ourselves.
9583 return true; // furniture and or obstacle wins.
9584 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
9585 add_msg( _( "There's stuff in the way." ) );
9586 u.moves -= 50;
9587 return true;
9588 }
9589
9590 u.moves -= str_req * 10;
9591 // Additional penalty if we can't comfortably move it.
9592 if( str_req > u.get_str() ) {
9593 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
9594 if( move_penalty <= 1000 ) {
9595 if( u.get_str() >= str_req - 3 ) {
9596 u.moves -= std::max( 3000, move_penalty * 10 );
9597 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
9598 if( one_in( 3 ) ) {
9599 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
9600 return true;
9601 }
9602 } else {
9603 u.moves -= 100;
9604 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
9605 return true;
9606 }
9607 }
9608 u.moves -= move_penalty;
9609 if( move_penalty > 500 ) {
9610 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
9611 furntype.name() );
9612 } else if( move_penalty > 200 ) {
9613 if( one_in( 3 ) ) { // Nag only occasionally.
9614 add_msg( _( "It takes some time to move the heavy %s." ),
9615 furntype.name() );
9616 }
9617 }
9618 }
9620 _( "a scraping noise." ), true, "misc", "scraping" );
9621
9623 ( tripoint_abs_ms( m.getabs( fpos ) ) );
9624
9625 // Actually move the furniture.
9626 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
9627 m.furn_set( fpos, f_null );
9628
9629 if( fire_intensity == 1 && !pulling_furniture ) {
9630 m.remove_field( fpos, fd_fire );
9631 m.set_field_intensity( fdest, fd_fire, fire_intensity );
9632 m.set_field_age( fdest, fd_fire, fire_age );
9633 }
9634
9635 // Is there is only liquids on the ground, remove them after moving furniture.
9636 if( dst_items > 0 && only_liquid_items ) {
9637 m.i_clear( fdest );
9638 }
9639
9640 if( src_items > 0 ) { // Move the stuff inside.
9641 if( dst_item_ok && src_item_ok ) {
9642 // Assume contents of both cells are legal, so we can just swap contents.
9643 std::list<item> temp;
9644 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
9645 std::back_inserter( temp ) );
9646 m.i_clear( fpos );
9647 for( auto item_iter = m.i_at( fdest ).begin();
9648 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
9649 m.i_at( fpos ).insert( *item_iter );
9650 }
9651 m.i_clear( fdest );
9652 for( auto &cur_item : temp ) {
9653 m.i_at( fdest ).insert( cur_item );
9654 }
9655 } else {
9656 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
9657 }
9658 }
9659
9660 if( shifting_furniture ) {
9661 // We didn't move
9662 tripoint d_sum = u.grab_point + dp;
9663 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
9664 u.grab_point = d_sum; // furniture moved relative to us
9665 } else { // we pushed furniture out of reach
9666 add_msg( _( "You let go of the %s." ), furntype.name() );
9667 u.grab( OBJECT_NONE );
9668 }
9669 return true; // We moved furniture but stayed still.
9670 }
9671
9672 if( pushing_furniture && m.impassable( fpos ) ) {
9673 // Not sure how that chair got into a wall, but don't let player follow.
9674 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
9675 furntype.name(), m.tername( fdest ) );
9676 u.grab( OBJECT_NONE );
9677 return true;
9678 }
9679
9680 return false;
9681}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4069
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:664
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:4831
void insert(const item &newitem) override
Definition: map.cpp:158
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5558
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5432
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5466
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5472
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5445
std::string tername(const tripoint &p) const
Definition: map.cpp:1768
void i_clear(const tripoint &p)
Definition: map.cpp:4220
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1419
bool has_floor(const tripoint &p) const
Definition: map.cpp:2066
tripoint grab_point
Definition: player.h:235
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1097
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:515
bool has_flag(const std::string &flag) const
Definition: mapdata.h:419

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, Character::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 9683 of file game.cpp.

9684{
9685 if( u.get_grab_type() == OBJECT_NONE ) {
9686 return false;
9687 }
9688
9689 if( dp.z != 0 ) {
9690 // No dragging stuff up/down stairs yet!
9691 return false;
9692 }
9693
9694 // vehicle: pulling, pushing, or moving around the grabbed object.
9695 if( u.get_grab_type() == OBJECT_VEHICLE ) {
9696 return grabbed_veh_move( dp );
9697 }
9698
9699 if( u.get_grab_type() == OBJECT_FURNITURE ) {
9700 return grabbed_furn_move( dp );
9701 }
9702
9703 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
9705 u.grab( OBJECT_NONE );
9706 return false;
9707}
object_type get_grab_type() const
Definition: avatar.cpp:672
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:9511
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( u ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150
151 // Grabbed part has to stay at distance 1 to the player
152 // and in roughly the same direction.
153 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
154 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
155 const tripoint expected_pos = u.pos() + dp + from;
156 const tripoint actual_dir = expected_pos - new_part_pos;
157
158 grabbed_vehicle->adjust_zlevel( 1, dp );
159
160 // Set player location to illegal value so it can't collide with vehicle.
161 const tripoint player_prev = u.pos();
163 std::vector<veh_collision> colls;
164 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
165 u.setpos( player_prev );
166 if( !colls.empty() ) {
167 blocker_name = colls.front().target_name;
168 }
169 return failed ? tripoint_zero : actual_dir;
170 };
171
172 // First try the move as intended
173 // But if that fails and the move is a zig-zag, try to recover:
174 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
175 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
176 if( final_dp_veh == tripoint_zero && zigzag ) {
177 final_dp_veh = get_move_dir( -prev_grab, -dp );
178 next_grab = -dp;
179 }
180
181 if( final_dp_veh == tripoint_zero ) {
182 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
183 u.grab_point = prev_grab;
184 return true;
185 }
186
187 u.grab_point = next_grab;
188
189 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
190
191 if( grabbed_vehicle ) {
192 grabbed_vehicle->shift_zlevel();
193 grabbed_vehicle->check_falling_or_floating();
194 } else {
195 debugmsg( "Grabbed vehicle disappeared" );
196 return false;
197 }
198
199 for( int p : wheel_indices ) {
200 if( one_in( 2 ) ) {
201 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
202 grabbed_vehicle->handle_trap( wheel_p, p );
203 }
204 }
205
206 return false;
207
208}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1178
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1839
void init(point ad)
Definition: tileray.cpp:27
units::angle dir() const
Definition: tileray.cpp:74
void turn(units::angle deg)
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3282
bool valid_wheel_config() const
Definition: vehicle.cpp:4461
units::mass total_mass() const
Definition: vehicle.cpp:3307
std::vector< int > wheelcache
Definition: vehicle.h:1843
void check_falling_or_floating()
point pivot_point() const
Definition: vehicle.cpp:5828
tileray face
Definition: vehicle.h:1973
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6972
int part_count() const
Definition: vehicle.cpp:7079
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
void precalc_mounts(int idir, units::angle dir, point pivot)
Definition: vehicle.cpp:3151
monster * get_pet(int p) const
Definition: vehicle.cpp:3263
vehicle_part & part(int part_num)
Definition: vehicle.cpp:7084
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3287
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1952
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:259
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:372

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, Character::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1521 of file handle_action.cpp.

1522{
1523 std::string action;
1524 input_context ctxt;
1526 user_turn current_turn;
1527 // Check if we have an auto-move destination
1528 if( u.has_destination() ) {
1530 if( act == ACTION_NULL ) {
1531 add_msg( m_info, _( "Auto-move canceled" ) );
1533 return false;
1534 }
1535 } else if( u.has_destination_activity() ) {
1536 // starts destination activity after the player successfully reached his destination
1538 return false;
1539 } else {
1540 // No auto-move, ask player for input
1541 ctxt = get_player_input( action );
1542 }
1543
1544 const optional_vpart_position vp = m.veh_at( u.pos() );
1545 bool veh_ctrl = !u.is_dead_state() &&
1546 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1547
1548 // If performing an action with right mouse button, co-ordinates
1549 // of location clicked.
1550 std::optional<tripoint> mouse_target;
1551
1552 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1553 uquit = QUIT_DIED;
1554 return false;
1555 }
1556
1557 if( act == ACTION_NULL ) {
1559
1560 if( act == ACTION_KEYBINDINGS ) {
1561 // already handled by input context
1562 return false;
1563 }
1564
1565 if( act == ACTION_MAIN_MENU ) {
1566 if( uquit == QUIT_WATCH ) {
1567 return false;
1568 }
1569 // No auto-move actions have or can be set at this point.
1571 destination_preview.clear();
1573 if( act == ACTION_NULL ) {
1574 return false;
1575 }
1576 }
1577
1578 if( act == ACTION_ACTIONMENU ) {
1579 if( uquit == QUIT_WATCH ) {
1580 return false;
1581 }
1582 // No auto-move actions have or can be set at this point.
1584 destination_preview.clear();
1586 if( act == ACTION_NULL ) {
1587 return false;
1588 }
1589#if defined(__ANDROID__)
1590 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1591 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1592 }
1593#endif
1594 }
1595
1596 if( act == ACTION_KEYBINDINGS ) {
1598 destination_preview.clear();
1599 act = ctxt.display_menu( true );
1600 if( act == ACTION_NULL ) {
1601 return false;
1602 }
1603 }
1604
1607 }
1608
1609 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1610 // Mouse button click
1611 if( veh_ctrl ) {
1612 // No mouse use in vehicle
1613 return false;
1614 }
1615
1616 if( u.is_dead_state() ) {
1617 // do not allow mouse actions while dead
1618 return false;
1619 }
1620
1621 const std::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1622 if( !mouse_pos ) {
1623 return false;
1624 } else if( !u.sees( *mouse_pos ) ) {
1625 // Not clicked in visible terrain
1626 return false;
1627 }
1628 mouse_target = mouse_pos;
1629
1630 if( act == ACTION_SELECT ) {
1631 // Note: The following has the potential side effect of
1632 // setting auto-move destination state in addition to setting
1633 // act.
1634 if( !try_get_left_click_action( act, *mouse_target ) ) {
1635 return false;
1636 }
1637 } else if( act == ACTION_SEC_SELECT ) {
1638 if( !try_get_right_click_action( act, *mouse_target ) ) {
1639 return false;
1640 }
1641 }
1642 } else if( act != ACTION_TIMEOUT ) {
1643 // act has not been set for an auto-move, so clearing possible
1644 // auto-move destinations. Since initializing an auto-move with
1645 // the mouse may span across multiple actions, we do not clear the
1646 // auto-move destination if the action is only a timeout, as this
1647 // would require the user to double click quicker than the
1648 // timeout delay.
1650 destination_preview.clear();
1651 }
1652 }
1653
1654 if( act == ACTION_NULL ) {
1655 const input_event &&evt = ctxt.get_raw_input();
1656 if( !evt.sequence.empty() ) {
1657 const int ch = evt.get_first_input();
1658 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1659 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1660 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1661 if( const std::optional<std::string> hint =
1663 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1664 "the current context." ),
1665 *hint );
1666 }
1667 }
1668 }
1669 return false;
1670 }
1671
1672 // This has no action unless we're in a special game mode.
1673 gamemode->pre_action( act );
1674
1675 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1676
1677 int before_action_moves = u.moves;
1678
1679 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1680 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1681 switch( act ) {
1684 break;
1685
1686 case ACTION_CENTER:
1689 break;
1690
1691 case ACTION_SHIFT_N:
1692 case ACTION_SHIFT_NE:
1693 case ACTION_SHIFT_E:
1694 case ACTION_SHIFT_SE:
1695 case ACTION_SHIFT_S:
1696 case ACTION_SHIFT_SW:
1697 case ACTION_SHIFT_W:
1698 case ACTION_SHIFT_NW: {
1699 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1708 };
1710 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1711 }
1712 break;
1713
1714 case ACTION_LOOK:
1715 look_around();
1716 break;
1717
1718 case ACTION_KEYBINDINGS:
1719 // already handled by input context
1720 break;
1721
1722 default:
1723 break;
1724 }
1725 }
1726
1727 // actions allowed only while alive
1728 if( !u.is_dead_state() ) {
1729 switch( act ) {
1730 case ACTION_NULL:
1731 case NUM_ACTIONS:
1732 break; // dummy entries
1733 case ACTION_ACTIONMENU:
1734 case ACTION_MAIN_MENU:
1735 case ACTION_KEYBINDINGS:
1736 break; // handled above
1737
1738 case ACTION_TIMEOUT:
1739 if( check_safe_mode_allowed( false ) ) {
1741 }
1742 break;
1743
1744 case ACTION_PAUSE:
1745 if( check_safe_mode_allowed() ) {
1747 }
1748 break;
1749
1750 case ACTION_CYCLE_MOVE:
1752 break;
1753
1754 case ACTION_RESET_MOVE:
1756 break;
1757
1758 case ACTION_TOGGLE_RUN:
1760 break;
1761
1764 break;
1765
1768 break;
1769
1770 case ACTION_MOVE_FORTH:
1772 case ACTION_MOVE_RIGHT:
1774 case ACTION_MOVE_BACK:
1776 case ACTION_MOVE_LEFT:
1778 if( !u.get_value( "remote_controlling" ).empty() &&
1782 } else if( veh_ctrl ) {
1783 // vehicle control uses x for steering and y for ac/deceleration,
1784 // so no rotation needed
1786 } else {
1788 if( auto_travel_mode && !u.is_auto_moving() ) {
1789 for( int i = 0; i < SEEX; i++ ) {
1790 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1791 u.posy() + dest_delta.y * ( SEEX - i ),
1792 u.posz() );
1794 auto_travel_destination,
1796 u.get_path_avoid() );
1797 if( !destination_preview.empty() ) {
1800 break;
1801 }
1802 }
1805 if( dest_next == point_zero ) {
1807 }
1808 dest_delta = dest_next;
1809 }
1810 if( !avatar_action::move( u, m, dest_delta ) ) {
1811 // auto-move should be canceled due to a failed move or obstacle
1813 }
1814 }
1815 break;
1816 case ACTION_MOVE_DOWN:
1817 if( u.is_mounted() ) {
1818 auto mon = u.mounted_creature.get();
1819 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1820 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1821 break;
1822 }
1823 }
1824 if( !u.in_vehicle ) {
1825 vertical_move( -1, false );
1826 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1828 }
1829 break;
1830
1831 case ACTION_MOVE_UP:
1832 if( u.is_mounted() ) {
1833 auto mon = u.mounted_creature.get();
1834 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1835 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1836 break;
1837 }
1838 }
1839 if( !u.in_vehicle ) {
1840 vertical_move( 1, false );
1841 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1843 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1844 !vp->vehicle().has_sufficient_rotorlift() ) {
1845 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1846 }
1847 break;
1848
1849 case ACTION_OPEN:
1851 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1852 } else if( u.is_mounted() ) {
1853 add_msg( m_info, _( "You can't open things while you're riding." ) );
1854 } else {
1855 open();
1856 }
1857 break;
1858
1859 case ACTION_CLOSE:
1861 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1862 } else if( u.is_mounted() ) {
1863 auto mon = u.mounted_creature.get();
1864 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1865 add_msg( m_info, _( "You can't close things while you're riding." ) );
1866 }
1867 } else if( mouse_target ) {
1868 doors::close_door( m, u, *mouse_target );
1869 } else {
1870 close();
1871 }
1872 break;
1873
1874 case ACTION_SMASH:
1875 if( veh_ctrl ) {
1876 handbrake();
1877 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1878 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1879 } else {
1880 smash();
1881 }
1882 break;
1883
1884 case ACTION_EXAMINE:
1886 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1887 } else if( mouse_target ) {
1888 examine( *mouse_target );
1889 } else {
1890 examine();
1891 }
1892 break;
1893
1894 case ACTION_ADVANCEDINV:
1896 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1897 } else if( u.is_mounted() ) {
1898 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1899 } else {
1901 }
1902 break;
1903
1904 case ACTION_PICKUP:
1906 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1907 } else if( u.is_mounted() ) {
1908 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1909 } else if( mouse_target ) {
1910 pickup( *mouse_target );
1911 } else {
1912 pickup();
1913 }
1914 break;
1915
1916 case ACTION_PICKUP_FEET:
1918 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1919 } else {
1920 pickup_feet();
1921 }
1922 break;
1923
1924 case ACTION_GRAB:
1926 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1927 } else if( u.is_mounted() ) {
1928 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1929 } else {
1930 grab();
1931 }
1932 break;
1933
1934 case ACTION_HAUL:
1936 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1937 } else if( u.is_mounted() ) {
1938 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1939 } else {
1940 haul();
1941 }
1942 break;
1943
1944 case ACTION_BUTCHER:
1946 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1947 } else if( u.is_mounted() ) {
1948 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1949 } else {
1950 butcher();
1951 }
1952 break;
1953
1954 case ACTION_CHAT:
1955 chat();
1956 break;
1957
1958 case ACTION_PEEK:
1960 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1961 } else if( u.is_mounted() ) {
1962 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1963 } else {
1964 peek();
1965 }
1966 break;
1967
1968 case ACTION_LIST_ITEMS:
1970 break;
1971
1972 case ACTION_ZONES:
1973 zones_manager();
1974 break;
1975
1976 case ACTION_LOOT:
1977 loot();
1978 break;
1979
1980 case ACTION_INVENTORY:
1982 break;
1983
1984 case ACTION_COMPARE:
1985 game_menus::inv::compare( u, std::nullopt );
1986 break;
1987
1988 case ACTION_ORGANIZE:
1990 break;
1991
1992 case ACTION_USE:
1993 // Shell-users are presumed to be able to mess with their inventories, etc
1994 // while in the shell. Eating, gear-changing, and item use are OK.
1996 break;
1997
1998 case ACTION_USE_WIELDED:
2000 break;
2001
2002 case ACTION_WEAR:
2003 wear();
2004 break;
2005
2006 case ACTION_TAKE_OFF:
2007 takeoff();
2008 break;
2009
2010 case ACTION_EAT:
2011 if( !avatar_action::eat_here( u ) ) {
2013 }
2014 break;
2015
2017 if( !avatar_action::eat_here( u ) ) {
2019 }
2020 break;
2021
2022 case ACTION_READ:
2023 // Shell-users are presumed to have the book just at an opening and read it that way
2024 read();
2025 break;
2026
2027 case ACTION_WIELD:
2029 break;
2030
2031 case ACTION_PICK_STYLE:
2032 u.martial_arts_data->pick_style( u );
2033 break;
2034
2035 case ACTION_RELOAD_ITEM:
2037 break;
2038
2041 break;
2042
2045 break;
2046
2047 case ACTION_UNLOAD:
2049 break;
2050
2051 case ACTION_MEND:
2053 break;
2054
2055 case ACTION_THROW: {
2056 item_location loc;
2057 avatar_action::plthrow( g->u, loc );
2058 break;
2059 }
2060
2061 case ACTION_FIRE:
2062 fire();
2063 break;
2064
2065 case ACTION_CAST_SPELL:
2066 cast_spell();
2067 break;
2068
2069 case ACTION_FIRE_BURST: {
2070 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2072 }
2073 break;
2074 }
2075
2077 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2078 if( u.weapon.gun_all_modes().size() > 1 ) {
2080 } else {
2081 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2082 }
2083 }
2084 break;
2085
2087 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2089 }
2090 break;
2091
2092 case ACTION_DROP:
2093 // You CAN drop things to your own tile while in the shell.
2094 drop();
2095 break;
2096
2097 case ACTION_DIR_DROP:
2099 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2100 } else {
2102 }
2103 break;
2104 case ACTION_BIONICS:
2105 show_bionics_ui( u );
2106 break;
2107 case ACTION_MUTATIONS:
2109 break;
2110
2111 case ACTION_SORT_ARMOR:
2113 break;
2114
2115 case ACTION_WAIT:
2116 wait();
2117 break;
2118
2119 case ACTION_CRAFT:
2121 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2122 } else if( u.is_mounted() ) {
2123 add_msg( m_info, _( "You can't craft while you're riding." ) );
2124 } else {
2125 u.craft();
2126 }
2127 break;
2128
2129 case ACTION_RECRAFT:
2131 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2132 } else if( u.is_mounted() ) {
2133 add_msg( m_info, _( "You can't craft while you're riding." ) );
2134 } else {
2135 u.recraft();
2136 }
2137 break;
2138
2139 case ACTION_LONGCRAFT:
2141 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2142 } else if( u.is_mounted() ) {
2143 add_msg( m_info, _( "You can't craft while you're riding." ) );
2144 } else {
2145 u.long_craft();
2146 }
2147 break;
2148
2149 case ACTION_DISASSEMBLE:
2150 if( u.controlling_vehicle ) {
2151 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2152 } else if( u.is_mounted() ) {
2153 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2154 } else {
2156 }
2157 break;
2158
2159 case ACTION_CONSTRUCT:
2160 if( u.in_vehicle ) {
2161 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2162 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2163 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2164 } else if( u.is_mounted() ) {
2165 add_msg( m_info, _( "You can't construct while you're riding." ) );
2166 } else {
2167 construction_menu( false );
2168 }
2169 break;
2170
2171 case ACTION_SLEEP:
2172 if( veh_ctrl ) {
2173 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2174 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2175 _( "new default binding is '^'." ) ) );
2176 } else {
2177 sleep();
2178 }
2179 break;
2180
2183 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2184 } else if( u.is_mounted() ) {
2185 u.dismount();
2186 } else {
2188 }
2189 break;
2190
2193 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2194 break;
2195
2197 if( safe_mode == SAFE_MODE_OFF ) {
2199 mostseen = 0;
2200 add_msg( m_info, _( "Safe mode ON!" ) );
2201 } else {
2204 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2205 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2206 }
2210 }
2211 break;
2212
2214 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2215 add_msg( m_info, autosafemode_option.value_as<bool>()
2216 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2217 autosafemode_option.setNext();
2218 break;
2219 }
2220
2222 if( safe_mode == SAFE_MODE_STOP ) {
2223 add_msg( m_info, _( "Ignoring enemy!" ) );
2224 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2225 monster &critter = *elem;
2226 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2227 }
2229 } else if( u.has_effect( effect_laserlocked ) ) {
2230 if( u.has_trait( trait_PROF_CHURL ) ) {
2231 add_msg( m_warning, _( "You make the sign of the cross." ) );
2232 } else {
2233 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2234 }
2237 }
2238 break;
2239
2241 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2243 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2245 mostseen = 0;
2246 } else {
2247 get_safemode().show();
2248 }
2249 break;
2250
2251 case ACTION_SUICIDE:
2252 if( query_yn( _( "Commit suicide?" ) ) ) {
2253 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2254 u.apply_damage( &u, body_part_head, 99999 );
2255 u.moves = 0;
2256 u.place_corpse();
2258 }
2259 }
2260 break;
2261
2262 case ACTION_SAVE:
2263 if( query_yn( _( "Save and quit?" ) ) ) {
2264 if( save() ) {
2265 u.moves = 0;
2266 uquit = QUIT_SAVED;
2267 }
2268 }
2269 break;
2270
2271 case ACTION_QUICKSAVE:
2272 quicksave();
2273 return false;
2274
2275 case ACTION_QUICKLOAD:
2276 quickload();
2277 return false;
2278
2279 case ACTION_PL_INFO:
2281 break;
2282
2283 case ACTION_MAP:
2285 break;
2286
2287 case ACTION_SKY:
2288 if( m.is_outside( u.pos() ) ) {
2290 } else {
2291 add_msg( m_info, _( "You can't see the sky from here." ) );
2292 }
2293 break;
2294
2295 case ACTION_MISSIONS:
2296 list_missions();
2297 break;
2298
2299 case ACTION_SCORES:
2301 break;
2302
2303 case ACTION_DIARY:
2305 break;
2306
2307 case ACTION_FACTIONS:
2308 faction_manager_ptr->display();
2309 break;
2310
2311 case ACTION_MORALE:
2312 u.disp_morale();
2313 break;
2314
2315 case ACTION_MESSAGES:
2317 break;
2318
2319 case ACTION_HELP:
2321 break;
2322
2323 case ACTION_OPTIONS:
2324 get_options().show( true );
2325 break;
2326
2327 case ACTION_AUTOPICKUP:
2329 break;
2330
2331 case ACTION_AUTONOTES:
2333 break;
2334
2335 case ACTION_SAFEMODE:
2336 get_safemode().show();
2337 break;
2338
2341 break;
2342
2343 case ACTION_COLOR:
2344 all_colors.show_gui();
2345 break;
2346
2347 case ACTION_WORLD_MODS:
2348 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2349 break;
2350
2351 case ACTION_DEBUG:
2353 break; //don't do anything when sharing and not debugger
2354 }
2356 break;
2357
2360 break;
2361
2364 break;
2365
2368 break;
2369
2371 reload_tileset( []( std::string str ) {
2372 DebugLog( DL::Info, DC::Main ) << str;
2373 } );
2374 break;
2375
2377 get_options().get_option( "AUTO_FEATURES" ).setNext();
2378 get_options().save();
2379 //~ Auto Features are now ON/OFF
2380 add_msg( _( "%s are now %s." ),
2381 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2382 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2383 break;
2384
2386 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2387 get_options().save();
2388 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2389 add_msg( _( "%s is now set to %s." ),
2390 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2391 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2392 break;
2393
2395 get_options().get_option( "AUTO_MINING" ).setNext();
2396 get_options().save();
2397 //~ Auto Mining is now ON/OFF
2398 add_msg( _( "%s is now %s." ),
2399 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2400 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2401 break;
2402
2404 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2405 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2406 u.set_value( "THIEF_MODE_KEEP", "YES" );
2407 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2408 add_msg( _( "You will not pick up other peoples belongings." ) );
2409 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2410 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2411 u.set_value( "THIEF_MODE_KEEP", "YES" );
2412 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2413 add_msg( _( "You will pick up also those things that belong to others!" ) );
2414 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2415 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2416 u.set_value( "THIEF_MODE_KEEP", "NO" );
2417 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2418 add_msg( _( "You will be reminded not to steal." ) );
2419 } else {
2420 // ERROR
2421 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2422 }
2423 break;
2424
2426 get_options().get_option( "AUTO_FORAGING" ).setNext();
2427 get_options().save();
2428 //~ Auto Foraging is now set to x
2429 add_msg( _( "%s is now set to %s." ),
2430 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2431 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2432 break;
2433
2435 get_options().get_option( "AUTO_PICKUP" ).setNext();
2436 get_options().save();
2437 //~ Auto pickup is now set to x
2438 add_msg( _( "%s is now set to %s." ),
2439 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2440 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2441 break;
2442
2445 break; //don't do anything when sharing and not debugger
2446 }
2447 display_scent();
2448 break;
2449
2452 break; //don't do anything when sharing and not debugger
2453 }
2454 display_scent();
2455 break;
2456
2459 break; //don't do anything when sharing and not debugger
2460 }
2462 break;
2465 break; //don't do anything when sharing and not debugger
2466 }
2468 break;
2471 break; //don't do anything when sharing and not debugger
2472 }
2474 break;
2475
2478 break; //don't do anything when sharing and not debugger
2479 }
2481 break;
2482
2485 break; //don't do anything when sharing and not debugger
2486 }
2488 break;
2489
2492 break; //don't do anything when sharing and not debugger
2493 }
2495 break;
2496
2498 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2499 break;
2500
2503 break;
2504
2507 break; //don't do anything when sharing and not debugger
2508 }
2510 if( debug_mode ) {
2511 add_msg( m_info, _( "Debug mode ON!" ) );
2512 } else {
2513 add_msg( m_info, _( "Debug mode OFF!" ) );
2514 }
2515 break;
2516
2517 case ACTION_ZOOM_IN:
2518 zoom_in();
2520 break;
2521
2522 case ACTION_ZOOM_OUT:
2523 zoom_out();
2525 break;
2526
2527 case ACTION_ITEMACTION:
2529 break;
2530
2531 case ACTION_AUTOATTACK:
2533 break;
2534
2535 default:
2536 break;
2537 }
2538 }
2539 if( act != ACTION_TIMEOUT ) {
2540 u.mod_moves( -current_turn.moves_elapsed() );
2541 }
2542 gamemode->post_action( act );
2543
2544 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2545 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2546 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2547 return ( !u.is_dead_state() );
2548}
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:352
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:423
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:947
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:512
std::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:474
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:660
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:263
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:117
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:95
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:195
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:177
@ ACTION_READ
Open the read menu.
Definition: action.h:149
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:47
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:145
@ ACTION_SMASH
Smash something.
Definition: action.h:99
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:131
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:223
@ ACTION_HELP
Display help screen.
Definition: action.h:249
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:247
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:121
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:137
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:225
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:119
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:257
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:37
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:153
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:201
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:39
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:185
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:147
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:245
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:20
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:59
@ ACTION_CHAT
Chat with something.
Definition: action.h:113
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:159
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:53
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:239
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:261
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:151
@ ACTION_THROW
Open the throw menu.
Definition: action.h:165
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:129
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:213
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:65
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:133
@ ACTION_SCORES
Display scores screen.
Definition: action.h:241
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:111
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:27
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:63
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:25
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:251
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:193
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:203
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:123
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:235
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:163
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:215
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:139
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:233
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:169
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:181
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:207
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:221
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:55
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:209
@ ACTION_COLOR
Open color manager.
Definition: action.h:265
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:35
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:61
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:243
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:107
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:45
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:175
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:179
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:187
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:57
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:237
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:167
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:33
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:43
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:183
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:109
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:41
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:205
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:49
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:173
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:259
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:227
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:171
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:161
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:197
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:143
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:105
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:267
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:135
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:51
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:97
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:157
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:155
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:103
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:199
@ ACTION_DISTRACTION_MANAGER
Open distraction manager.
Definition: action.h:269
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:141
@ ACTION_DIARY
Display diary window.
Definition: action.h:253
void create_advanced_inv()
void show_armor_layers_ui(Character &who)
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
void show_bionics_ui(Character &who)
Definition: bionics_ui.cpp:537
const bodypart_str_id body_part_head("head")
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:365
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1559
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2493
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9926
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9940
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:148
void dismount()
Definition: character.cpp:1172
item weapon
Definition: character.h:1555
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1351
std::string get_value(const std::string &key) const
Definition: creature.cpp:1361
void mod_moves(int nmoves)
Definition: creature.cpp:1428
void cycle_move_mode()
Definition: avatar.cpp:1187
void toggle_map_memory()
Definition: avatar.cpp:122
void toggle_crouch_mode()
Definition: avatar.cpp:1171
void toggle_run_mode()
Definition: avatar.cpp:1162
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:1001
void reset_move_mode()
Definition: avatar.cpp:1180
static void show_diary_ui(diary *c_diary)
Definition: diary_ui.cpp:164
void item_action_menu()
void display_radiation()
Definition: game.cpp:11238
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2297
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:8618
void reload_tileset(std::function< void(std::string)> out)
Definition: game.cpp:427
void pickup_feet()
Definition: game.cpp:5619
void zones_manager()
Definition: game.cpp:6092
int turnssincelastmon
Definition: game.h:1020
void display_visibility()
Definition: game.cpp:11152
void display_scent()
Definition: game.cpp:11117
bool save()
Returns false if saving failed.
Definition: game.cpp:2732
void butcher()
Definition: game.cpp:8300
void display_temperature()
Definition: game.cpp:11138
bool auto_travel_mode
Definition: game.h:1017
void zoom_out()
Definition: game.cpp:7042
void toggle_pixel_minimap()
Definition: game.cpp:416
void toggle_debug_hour_timer()
Definition: game.cpp:11184
void display_transparency()
Definition: game.cpp:11245
void list_items_monsters()
Definition: game.cpp:7220
void chat()
Definition: npctalk.cpp:395
void quickload()
Definition: game.cpp:11280
void pickup()
Definition: game.cpp:5597
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:9966
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11212
void control_vehicle()
Definition: game.cpp:5166
void peek()
Definition: game.cpp:5626
std::optional< tripoint > look_around(bool force_3d=false)
Definition: game.cpp:6567
void drop()
Definition: game.cpp:8038
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2325
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:8556
void zoom_in()
Definition: game.cpp:7054
void toggle_fullscreen()
Definition: game.cpp:406
void display_vehicle_ai()
Definition: game.cpp:11145
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:2980
void drop_in_direction()
Definition: game.cpp:8043
void display_help()
Definition: help.cpp:140
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1293
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:993
std::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1332
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:410
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6517
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7915
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4820
bool is_gunmod() const
Definition: item.cpp:6547
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7834
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7906
bool is_outside(const tripoint &p) const
Definition: map.cpp:2619
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:256
short ignoring
Definition: monster.h:504
cOpt & get_option(const std::string &name)
Definition: options.cpp:3382
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2759
void show_adm()
Definition: panels.cpp:2295
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:341
int movecounter
Definition: player.h:247
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:352
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:361
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
std::optional< construction_id > construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ Main
Generic messages related to game startup and operation.
#define DebugLog(lev, cl)
DebugLog.
Definition: debug.h:274
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
static void rcdrive(point d)
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
void show_mutations_ui(Character &who)
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void reload_wielded(bool prompt=false)
Reload wielded item.
void reload_item()
Prompt to reload some item.
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void wield()
Prompt to wield some item.
void plthrow(avatar &you, item_location loc, const std::optional< tripoint > &blind_throw_from_pos=std::nullopt)
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void reload_weapon(bool try_everything=true)
Reload a wielded gun/tool.
void mend(avatar &you, item_location loc)
void unload(avatar &you)
Prompts to unload some item.
void use_item(avatar &you, item_location loc)
Use a tool at given location.
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void do_pause(Character &who)
Do pause action ('.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void common(avatar &you)
void compare(player &p, const std::optional< tripoint > &offset)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3805
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:141
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:267
static constexpr point point_north_east
Definition: point.h:263
static constexpr point point_north_west
Definition: point.h:269
@ sleep
Will recharge only when character is asleep.
An instance of an input, like a keypress etc.
Definition: input.h:91
std::vector< int > sequence
Definition: input.h:97
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:92
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIARY, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DISTRACTION_MANAGER, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, Character::apply_damage(), auto_travel_mode, avatar_action::autoattack(), bio_remote, body_part_head, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, DebugLog, destination_preview, crafting::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), character_funcs::do_pause(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), avatar::get_avatar_diary(), input_context::get_coordinates(), get_delta_from_movement_action(), get_distraction_manager(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), Character::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, Main, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), avatar_action::reload_item(), reload_tileset(), avatar_action::reload_weapon(), avatar_action::reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), distraction_manager::distraction_manager_gui::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), show_armor_layers_ui(), show_bionics_ui(), diary::show_diary_ui(), auto_notes::auto_note_settings::show_gui(), show_mutations_ui(), show_scores_ui(), sleep, smash(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), avatar_funcs::use_item(), use_tiles, user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), avatar_action::wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 1976 of file game.cpp.

1977{
1979 const std::string action = ctxt.handle_input( 0 );
1980 bool refresh = true;
1981 if( action == "pause" || action == "main_menu" ) {
1983 cancel_activity_query( _( "Confirm:" ) );
1984 }
1985 } else if( action == "player_data" ) {
1987 } else if( action == "messages" ) {
1989 } else if( action == "help" ) {
1991 } else if( action != "HELP_KEYBINDINGS" ) {
1992 refresh = false;
1993 }
1994 if( refresh ) {
1997 }
1998}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1760
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:848
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2002 of file game.cpp.

2003{
2004 std::optional<tripoint> liveview_pos;
2005
2006 do {
2007 action = ctxt.handle_input();
2008 if( action == "MOUSE_MOVE" ) {
2009 const std::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2010 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2011 liveview_pos = mouse_pos;
2012 liveview.show( *liveview_pos );
2013 } else if( !mouse_pos ) {
2014 liveview_pos.reset();
2015 liveview.hide();
2016 }
2018 }
2019 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2020
2021 if( action != "TIMEOUT" ) {
2022 // Keyboard event, break out of animation loop
2023 liveview.hide();
2024 return false;
2025 }
2026
2027 // Mouse movement or un-handled key
2028 return true;
2029}
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 530 of file game.cpp.

531{
532 return gamemode && gamemode->id() != special_game_type::NONE;
533}

References gamemode, and NONE.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11252 of file game.cpp.

11253{
11255 last_save_timestamp = time( nullptr );
11256}

References last_save_timestamp, moves_since_last_save, and time.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 400 of file game_inventory.cpp.

402{
404 title, radius, none_message );
405}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:326

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8686 of file game.cpp.

8687{
8688 return !( get_dangerous_tile( dest_loc ).empty() );
8689}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8708

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 4831 of file game.cpp.

4832{
4833 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
4834 critter_at( p ) == nullptr;
4835}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2370 of file game.cpp.

2371{
2372 if( uquit == QUIT_WATCH ) {
2373 // deny player movement and dodging
2374 u.moves = 0;
2375 // prevent pain from updating
2376 u.set_pain( 0 );
2377 // prevent dodging
2378 u.dodges_left = 0;
2379 return false;
2380 }
2381 if( uquit == QUIT_DIED ) {
2382 if( u.in_vehicle ) {
2383 m.unboard_vehicle( u.pos() );
2384 }
2385 u.place_corpse();
2386 return true;
2387 }
2388 if( uquit == QUIT_SUICIDE ) {
2389 if( u.in_vehicle ) {
2390 m.unboard_vehicle( u.pos() );
2391 }
2392 return true;
2393 }
2394 if( uquit != QUIT_NO ) {
2395 return true;
2396 }
2397 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2398 if( u.is_dead_state() ) {
2399 if( get_option<bool>( "PROMPT_ON_CHARACTER_DEATH" ) &&
2400 !query_yn(
2401 _( "Your character is dead, do you accept this?\n\nSelect Yes to abandon the character to their fate, select No to return to main menu." ) ) ) {
2402 return true;
2403 }
2404
2406 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2407 uquit = QUIT_WATCH;
2408 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2409 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2411 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2412 uquit = QUIT_DIED;
2413 } else {
2414 // Something funky happened here, just die.
2415 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2416 uquit = QUIT_DIED;
2417 }
2418 return is_game_over();
2419 }
2420 return false;
2421}
int dodges_left
Definition: character.h:568
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: character.cpp:781
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:198
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, Character::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, Character::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3571 of file game.cpp.

3572{
3573 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3574 get_option<int>( "SAFEMODEPROXIMITY" );
3575 return is_hostile_within( distance );
3576}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3583

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3578 of file game.cpp.

3579{
3581}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:200

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3583 of file game.cpp.

3584{
3585 for( auto &critter : u.get_visible_creatures( distance ) ) {
3586 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3587 return critter;
3588 }
3589 }
3590
3591 return nullptr;
3592}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:167

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 4837 of file game.cpp.

4838{
4839 return weather::is_in_sunlight( m, p, get_weather().weather_id );
4840}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3217 of file game.cpp.

3218{
3219 const tripoint diff( u.pos() + u.view_offset - p );
3220
3221 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3222 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3223}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 4842 of file game.cpp.

4843{
4844 return weather::is_sheltered( m, p );
4845}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6022 of file game.cpp.

6023{
6024 return zones_manager_open;
6025}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1052

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1553
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1256
void restack(player &p)
Definition: inventory.cpp:399
void unsort()
Definition: inventory.cpp:227
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult,
Creature source 
)

Definition at line 4236 of file game.cpp.

4238{
4239 std::vector<tripoint> traj;
4240 traj.clear();
4241 traj = line_to( s, t, 0, 0 );
4242 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4243 traj = continue_line( traj, force );
4244 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4245
4246 knockback( traj, stun, dam_mult, source );
4247}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult,
Creature source = nullptr 
)

Definition at line 4253 of file game.cpp.

4255{
4256 // TODO: make the force parameter actually do something.
4257 // the header file says higher force causes more damage.
4258 // perhaps that is what it should do?
4259
4260 // TODO: refactor this so it's not copy/pasted 3 times
4261 tripoint tp = traj.front();
4262 if( !critter_at( tp ) ) {
4263 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4264 return;
4265 }
4266 std::size_t force_remaining = traj.size();
4267 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4268 tripoint start_pos = targ->pos();
4269
4270 if( stun > 0 ) {
4271 targ->add_effect( effect_stunned, 1_turns * stun );
4272 add_msg( _( "%s was stunned!" ), targ->name() );
4273 }
4274 for( size_t i = 1; i < traj.size(); i++ ) {
4275 if( m.impassable( traj[i].xy() ) || m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) {
4276 targ->setpos( traj[i - 1] );
4277 force_remaining = traj.size() - i;
4278 if( stun != 0 ) {
4279 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4280 add_msg( _( "%s was stunned!" ), targ->name() );
4281 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4282 targ->apply_damage( source, bodypart_id( "torso" ), dam_mult * force_remaining );
4283 targ->check_dead_state();
4284 }
4285 m.bash( traj[i], 2 * dam_mult * force_remaining );
4286 break;
4287 } else if( critter_at( traj[i] ) ) {
4288 targ->setpos( traj[i - 1] );
4289 force_remaining = traj.size() - i;
4290 if( stun != 0 ) {
4291 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4292 add_msg( _( "%s was stunned!" ), targ->name() );
4293 }
4294 traj.erase( traj.begin(), traj.begin() + i );
4295 if( critter_at<monster>( traj.front() ) ) {
4296 add_msg( _( "%s collided with something else and sent it flying!" ),
4297 targ->name() );
4298 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4299 if( guy->male ) {
4300 add_msg( _( "%s collided with someone else and sent him flying!" ),
4301 targ->name() );
4302 } else {
4303 add_msg( _( "%s collided with someone else and sent her flying!" ),
4304 targ->name() );
4305 }
4306 } else if( u.pos() == traj.front() ) {
4307 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4308 }
4309 knockback( traj, stun, dam_mult, source );
4310 break;
4311 }
4312 targ->setpos( traj[i] );
4313 if( m.has_flag( "LIQUID", targ->pos() ) && targ->can_drown() && !targ->is_dead() ) {
4314 targ->die( source );
4315 if( u.sees( *targ ) ) {
4316 add_msg( _( "The %s drowns!" ), targ->name() );
4317 }
4318 }
4319 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4320 !targ->is_dead() ) {
4321 targ->die( source );
4322 if( u.sees( *targ ) ) {
4323 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4324 }
4325 }
4326 tp = traj[i];
4327 if( start_pos != targ->pos() ) {
4328 map &here = get_map();
4329 here.creature_on_trap( *targ );
4330 }
4331 }
4332 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4333 tripoint start_pos = targ->pos();
4334
4335 if( stun > 0 ) {
4336 targ->add_effect( effect_stunned, 1_turns * stun );
4337 add_msg( _( "%s was stunned!" ), targ->name );
4338 }
4339 for( size_t i = 1; i < traj.size(); i++ ) {
4340 if( m.impassable( traj[i].xy() ) ||
4341 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4342 targ->setpos( traj[i - 1] );
4343 force_remaining = traj.size() - i;
4344 if( stun != 0 ) {
4345 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4346 if( targ->has_effect( effect_stunned ) ) {
4347 add_msg( _( "%s was stunned!" ), targ->name );
4348 }
4349
4350 std::array<bodypart_id, 8> bps = {{
4351 bodypart_id( "head" ),
4352 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4353 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4354 bodypart_id( "torso" ),
4355 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4356 }
4357 };
4358 for( const bodypart_id &bp : bps ) {
4359 if( one_in( 2 ) ) {
4360 targ->deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4361 }
4362 }
4363 targ->check_dead_state();
4364 }
4365 m.bash( traj[i], 2 * dam_mult * force_remaining );
4366 break;
4367 } else if( critter_at( traj[i] ) ) {
4368 targ->setpos( traj[i - 1] );
4369 force_remaining = traj.size() - i;
4370 if( stun != 0 ) {
4371 add_msg( _( "%s was stunned!" ), targ->name );
4372 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4373 }
4374 traj.erase( traj.begin(), traj.begin() + i );
4375 const tripoint &traj_front = traj.front();
4376 if( critter_at<monster>( traj_front ) ) {
4377 add_msg( _( "%s collided with something else and sent it flying!" ),
4378 targ->name );
4379 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4380 if( guy->male ) {
4381 add_msg( _( "%s collided with someone else and sent him flying!" ),
4382 targ->name );
4383 } else {
4384 add_msg( _( "%s collided with someone else and sent her flying!" ),
4385 targ->name );
4386 }
4387 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4389 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4390 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4391 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4392 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4393 }
4394 knockback( traj, stun, dam_mult, source );
4395 break;
4396 }
4397 targ->setpos( traj[i] );
4398 tp = traj[i];
4399
4400 if( start_pos != targ->pos() ) {
4401 map &here = get_map();
4402 here.creature_on_trap( *targ );
4403 }
4404 }
4405 } else if( u.pos() == tp ) {
4406 tripoint start_pos = u.pos();
4407
4408 if( stun > 0 ) {
4409 u.add_effect( effect_stunned, 1_turns * stun );
4410 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4411 "You were stunned for %d turns!",
4412 stun ),
4413 stun );
4414 }
4415 for( size_t i = 1; i < traj.size(); i++ ) {
4416 if( m.impassable( traj[i] ) ||
4417 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4418 u.setpos( traj[i - 1] );
4419 force_remaining = traj.size() - i;
4420 if( stun != 0 ) {
4421 if( u.has_effect( effect_stunned ) ) {
4422 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4423 "You were stunned AGAIN for %d turns!",
4424 force_remaining ),
4425 force_remaining );
4426 } else {
4427 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4428 "You were stunned for %d turns!",
4429 force_remaining ),
4430 force_remaining );
4431 }
4432 u.add_effect( effect_stunned, 1_turns * force_remaining );
4433 std::array<bodypart_id, 8> bps = {{
4434 bodypart_id( "head" ),
4435 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4436 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4437 bodypart_id( "torso" ),
4438 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4439 }
4440 };
4441 for( const bodypart_id &bp : bps ) {
4442 if( one_in( 2 ) ) {
4443 u.deal_damage( source, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4444 }
4445 }
4447 }
4448 m.bash( traj[i], 2 * dam_mult * force_remaining );
4449 break;
4450 } else if( critter_at( traj[i] ) ) {
4451 u.setpos( traj[i - 1] );
4452 force_remaining = traj.size() - i;
4453 if( stun != 0 ) {
4454 if( u.has_effect( effect_stunned ) ) {
4455 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4456 "You were stunned AGAIN for %d turns!",
4457 force_remaining ),
4458 force_remaining );
4459 } else {
4460 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4461 "You were stunned for %d turns!",
4462 force_remaining ),
4463 force_remaining );
4464 }
4465 u.add_effect( effect_stunned, 1_turns * force_remaining );
4466 }
4467 traj.erase( traj.begin(), traj.begin() + i );
4468 if( critter_at<monster>( traj.front() ) ) {
4469 add_msg( _( "You collided with something and sent it flying!" ) );
4470 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4471 if( guy->male ) {
4472 add_msg( _( "You collided with someone and sent him flying!" ) );
4473 } else {
4474 add_msg( _( "You collided with someone and sent her flying!" ) );
4475 }
4476 }
4477 knockback( traj, stun, dam_mult, source );
4478 break;
4479 }
4480 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4481 avatar_action::swim( m, u, u.pos() );
4482 } else {
4483 u.setpos( traj[i] );
4484 }
4485 tp = traj[i];
4486
4487 if( start_pos != u.pos() ) {
4488 map &here = get_map();
4489 here.creature_on_trap( u );
4490 }
4491 }
4492 }
4493}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8907
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8435
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:987
Manage and cache data about a part of the map.
Definition: map.h:384
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), map::creature_on_trap(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), get_map, Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, map::obstructed_by_vehicle_rotation(), one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3550 of file game.cpp.

3551{
3552 const float light = natural_light_level( zlev );
3553 return LIGHT_RANGE( light );
3554}
float natural_light_level(int zlev) const
Definition: game.cpp:3490
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_saves()

std::vector< std::string > game::list_active_saves ( )

Returns a list of currently active character saves.

Definition at line 2757 of file game.cpp.

2758{
2759 std::vector<std::string> saves;
2760 for( auto &worldsave : world_generator->active_world->world_saves ) {
2761 saves.push_back( worldsave.decoded_name() );
2762 }
2763 return saves;
2764}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7265 of file game.cpp.

7266{
7267 std::vector<map_item_stack> ground_items = item_list;
7268 int iInfoHeight = 0;
7269 int iMaxRows = 0;
7270 int width = 0;
7271 int max_name_width = 0;
7272
7273 //find max length of item name and resize window width
7274 for( const map_item_stack &cur_item : ground_items ) {
7275 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7276 if( item_len > max_name_width ) {
7277 max_name_width = item_len;
7278 }
7279 }
7280
7281 tripoint active_pos;
7282 map_item_stack *activeItem = nullptr;
7283
7284 catacurses::window w_items;
7285 catacurses::window w_items_border;
7286 catacurses::window w_item_info;
7287
7288 ui_adaptor ui;
7289 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7290 iInfoHeight = std::min( 25, TERMY / 2 );
7291 iMaxRows = TERMY - iInfoHeight - 2;
7292
7293 width = clamp( max_name_width, 45, TERMX / 3 );
7294
7295 const int offsetX = TERMX - width;
7296
7297 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7298 width - 2, point( offsetX + 1, 1 ) );
7299 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7300 width, point( offsetX, 0 ) );
7301 w_item_info = catacurses::newwin( iInfoHeight, width,
7302 point( offsetX, TERMY - iInfoHeight ) );
7303
7304 if( activeItem ) {
7305 centerlistview( active_pos, width );
7306 }
7307
7308 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7309 } );
7310 ui.mark_resize();
7311
7312 // use previously selected sorting method
7313 bool sort_radius = uistate.list_item_sort != 2;
7314 bool addcategory = !sort_radius;
7315
7316 // reload filter/priority settings on the first invocation, if they were active
7317 if( !uistate.list_item_init ) {
7320 }
7323 }
7326 }
7327 uistate.list_item_init = true;
7328 }
7329
7330 //this stores only those items that match our filter
7331 std::vector<map_item_stack> filtered_items =
7332 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7333 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7334 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7335 int iItemNum = ground_items.size();
7336
7337 const tripoint stored_view_offset = u.view_offset;
7338
7340
7341 int iActive = 0; // Item index that we're looking at
7342 bool refilter = true;
7343 int page_num = 0;
7344 int iCatSortNum = 0;
7345 int iScrollPos = 0;
7346 std::map<int, std::string> mSortCategory;
7347
7348 std::string action;
7349 input_context ctxt( "LIST_ITEMS" );
7350 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7351 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7352 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7353 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7354 ctxt.register_action( "PAGE_DOWN" );
7355 ctxt.register_action( "PAGE_UP" );
7356 ctxt.register_action( "NEXT_TAB" );
7357 ctxt.register_action( "PREV_TAB" );
7358 ctxt.register_action( "HELP_KEYBINDINGS" );
7359 ctxt.register_action( "QUIT" );
7360 ctxt.register_action( "FILTER" );
7361 ctxt.register_action( "RESET_FILTER" );
7362 ctxt.register_action( "EXAMINE" );
7363 ctxt.register_action( "COMPARE" );
7364 ctxt.register_action( "PRIORITY_INCREASE" );
7365 ctxt.register_action( "PRIORITY_DECREASE" );
7366 ctxt.register_action( "SORT" );
7367 ctxt.register_action( "TRAVEL_TO" );
7368
7369 std::optional<item_filter_type> filter_type;
7370
7371 ui.on_redraw( [&]( const ui_adaptor & ) {
7372 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7373
7374 if( ground_items.empty() ) {
7375 wnoutrefresh( w_items_border );
7376 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7377 } else {
7378 int iStartPos = 0;
7379 werase( w_items );
7380 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7381 int iNum = 0;
7382 bool high = false;
7383 bool low = false;
7384 int index = 0;
7385 int iCatSortOffset = 0;
7386
7387 for( int i = 0; i < iStartPos; i++ ) {
7388 if( !mSortCategory[i].empty() ) {
7389 iNum++;
7390 }
7391 }
7392 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7393 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7394 high = true;
7395 low = false;
7396 } else if( index >= lowPStart + iCatSortOffset ) {
7397 high = false;
7398 low = true;
7399 } else {
7400 high = false;
7401 low = false;
7402 }
7403
7404 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7405 int iThisPage = 0;
7406 if( !mSortCategory[iNum].empty() ) {
7407 iCatSortOffset++;
7408 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7409 } else {
7410 if( iNum == iActive ) {
7411 iThisPage = page_num;
7412 }
7413 std::string sText;
7414 if( iter->vIG.size() > 1 ) {
7415 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7416 }
7417 sText += iter->example->tname();
7418 if( iter->vIG[iThisPage].count > 1 ) {
7419 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7420 }
7421
7422 nc_color col = c_light_green;
7423 if( iNum != iActive ) {
7424 if( high ) {
7425 col = c_yellow;
7426 } else if( low ) {
7427 col = c_red;
7428 } else {
7429 col = iter->example->color_in_inventory();
7430 }
7431 }
7432 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7433 const int numw = iItemNum > 9 ? 2 : 1;
7434 const int x = iter->vIG[iThisPage].pos.x;
7435 const int y = iter->vIG[iThisPage].pos.y;
7436 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7437 iNum == iActive ? c_light_green : c_light_gray,
7438 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7440 ++iter;
7441 }
7442 } else {
7443 ++iter;
7444 }
7445 iNum++;
7446 }
7447 iNum = 0;
7448 for( int i = 0; i < iActive; i++ ) {
7449 if( !mSortCategory[i].empty() ) {
7450 iNum++;
7451 }
7452 }
7453 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7454 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7455 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7456 werase( w_item_info );
7457
7458 if( iItemNum > 0 && activeItem ) {
7459 item_location loc( map_cursor( u.pos() + activeItem->example_item_pos ),
7460 const_cast<item *>( activeItem->example ) );
7462 std::vector<iteminfo> this_item = activeItem->example->info( temperature );
7463 std::vector<iteminfo> item_info_dummy;
7464
7465 item_info_data dummy( "", "", this_item, item_info_dummy, iScrollPos );
7466 dummy.without_getch = true;
7467 dummy.without_border = true;
7468
7469 draw_item_info( w_item_info, dummy );
7470 }
7471 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7472 wnoutrefresh( w_items_border );
7473 }
7474
7475 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7476 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7477
7478 if( iItemNum > 0 && activeItem ) {
7479 // print info window title: < item name >
7480 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7481 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7482 activeItem->example->display_name() );
7483 wprintw( w_item_info, " >" );
7484 }
7485
7486 wnoutrefresh( w_items );
7487 wnoutrefresh( w_item_info );
7488
7489 if( filter_type ) {
7490 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7491 }
7492 } );
7493
7494 std::optional<tripoint> trail_start;
7495 std::optional<tripoint> trail_end;
7496 bool trail_end_x = false;
7497 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7498 trail_end_x );
7499 add_draw_callback( trail_cb );
7500
7501 do {
7502 if( action == "COMPARE" && activeItem ) {
7503 game_menus::inv::compare( u, active_pos );
7504 } else if( action == "FILTER" ) {
7505 filter_type = item_filter_type::FILTER;
7506 ui.invalidate_ui();
7508 .title( _( "Filter:" ) )
7509 .width( 55 )
7510 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7511 .identifier( "item_filter" )
7512 .max_length( 256 )
7513 .edit( sFilter );
7514 refilter = true;
7515 addcategory = !sort_radius;
7517 filter_type = std::nullopt;
7518 } else if( action == "RESET_FILTER" ) {
7519 sFilter.clear();
7520 filtered_items = ground_items;
7521 refilter = true;
7523 addcategory = !sort_radius;
7524 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7525 std::vector<iteminfo> dummy;
7526 const item *example_item = activeItem->example;
7527 // TODO: const_item_location
7528 item_location loc = item_location( u, const_cast<item *>( example_item ) );
7530 std::vector<iteminfo> this_item = example_item->info( temperature );
7531
7532 item_info_data info_data( example_item->tname(), example_item->type_name(), this_item, dummy );
7533 info_data.handle_scrolling = true;
7534
7536 return catacurses::newwin( TERMY, width - 5, point_zero );
7537 }, info_data );
7538 } else if( action == "PRIORITY_INCREASE" ) {
7539 filter_type = item_filter_type::HIGH_PRIORITY;
7540 ui.invalidate_ui();
7542 .title( _( "High Priority:" ) )
7543 .width( 55 )
7545 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7546 .identifier( "list_item_priority" )
7547 .max_length( 256 )
7548 .query_string();
7549 refilter = true;
7550 addcategory = !sort_radius;
7552 filter_type = std::nullopt;
7553 } else if( action == "PRIORITY_DECREASE" ) {
7554 filter_type = item_filter_type::LOW_PRIORITY;
7555 ui.invalidate_ui();
7557 .title( _( "Low Priority:" ) )
7558 .width( 55 )
7560 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7561 .identifier( "list_item_downvote" )
7562 .max_length( 256 )
7563 .query_string();
7564 refilter = true;
7565 addcategory = !sort_radius;
7567 filter_type = std::nullopt;
7568 } else if( action == "SORT" ) {
7569 if( sort_radius ) {
7570 sort_radius = false;
7571 addcategory = true;
7572 uistate.list_item_sort = 2; // list is sorted by category
7573 } else {
7574 sort_radius = true;
7575 uistate.list_item_sort = 1; // list is sorted by distance
7576 }
7577 highPEnd = -1;
7578 lowPStart = -1;
7579 iCatSortNum = 0;
7580
7581 mSortCategory.clear();
7582 refilter = true;
7583 } else if( action == "TRAVEL_TO" && activeItem ) {
7584 if( !u.sees( u.pos() + active_pos ) ) {
7585 add_msg( _( "You can't see that destination." ) );
7586 }
7587 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7588 u.get_path_avoid() );
7589 if( route.size() > 1 ) {
7590 route.pop_back();
7591 u.set_destination( route );
7592 break;
7593 } else {
7594 add_msg( m_info, _( "You can't travel there." ) );
7595 }
7596 }
7597 if( uistate.list_item_sort == 1 ) {
7598 ground_items = item_list;
7599 } else if( uistate.list_item_sort == 2 ) {
7600 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7601 }
7602
7603 if( refilter ) {
7604 refilter = false;
7605 filtered_items = filter_item_stacks( ground_items, sFilter );
7606 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7607 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7608 iActive = 0;
7609 page_num = 0;
7610 iItemNum = filtered_items.size();
7611 }
7612
7613 if( addcategory ) {
7614 addcategory = false;
7615 iCatSortNum = 0;
7616 mSortCategory.clear();
7617 if( highPEnd > 0 ) {
7618 mSortCategory[0] = _( "HIGH PRIORITY" );
7619 iCatSortNum++;
7620 }
7621 std::string last_cat_name;
7622 for( int i = std::max( 0, highPEnd );
7623 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7624 const std::string &cat_name = filtered_items[i].example->get_category().name();
7625 if( cat_name != last_cat_name ) {
7626 mSortCategory[i + iCatSortNum++] = cat_name;
7627 last_cat_name = cat_name;
7628 }
7629 }
7630 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7631 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7632 }
7633 if( !mSortCategory[0].empty() ) {
7634 iActive++;
7635 }
7636 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7637 }
7638
7639 if( action == "UP" ) {
7640 do {
7641 iActive--;
7642
7643 } while( !mSortCategory[iActive].empty() );
7644 iScrollPos = 0;
7645 page_num = 0;
7646 if( iActive < 0 ) {
7647 iActive = iItemNum - 1;
7648 }
7649 } else if( action == "DOWN" ) {
7650 do {
7651 iActive++;
7652
7653 } while( !mSortCategory[iActive].empty() );
7654 iScrollPos = 0;
7655 page_num = 0;
7656 if( iActive >= iItemNum ) {
7657 iActive = mSortCategory[0].empty() ? 0 : 1;
7658 }
7659 } else if( action == "RIGHT" ) {
7660 if( !filtered_items.empty() && activeItem ) {
7661 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7662 page_num = activeItem->vIG.size() - 1;
7663 }
7664 }
7665 } else if( action == "LEFT" ) {
7666 page_num = std::max( 0, page_num - 1 );
7667 } else if( action == "PAGE_UP" ) {
7668 iScrollPos--;
7669 } else if( action == "PAGE_DOWN" ) {
7670 iScrollPos++;
7671 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7672 u.view_offset = stored_view_offset;
7674 }
7675
7676 active_pos = tripoint_zero;
7677 activeItem = nullptr;
7678
7679 if( mSortCategory[iActive].empty() ) {
7680 auto iter = filtered_items.begin();
7681 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7682 if( mSortCategory[iNum].empty() ) {
7683 ++iter;
7684 }
7685 }
7686 if( iter != filtered_items.end() ) {
7687 active_pos = iter->vIG[page_num].pos;
7688 activeItem = &( *iter );
7689 }
7690 }
7691
7692 if( activeItem ) {
7693 centerlistview( active_pos, width );
7694 trail_start = u.pos();
7695 trail_end = u.pos() + active_pos;
7696 // Actually accessed from the terrain overlay callback `trail_cb` in the
7697 // call to `ui_manager::redraw`.
7698 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7699 trail_end_x = true;
7700 } else {
7701 u.view_offset = stored_view_offset;
7702 trail_start = trail_end = std::nullopt;
7703 }
7705
7707
7708 action = ctxt.handle_input();
7709 } while( action != "QUIT" );
7710
7711 u.view_offset = stored_view_offset;
7712 return game::vmenu_ret::QUIT;
7713}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:149
std::string list_item_upvote
Definition: game.h:1030
std::string list_item_downvote
Definition: game.h:1031
std::string sFilter
Definition: game.h:1029
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7151
std::vector< iteminfo > info() const
Return all the information about the item and its type as a vector.
Definition: item.cpp:3971
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4127
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9846
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
tripoint example_item_pos
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:121
int list_item_sort
Definition: uistate.h:118
bool list_item_downvote_active
Definition: uistate.h:124
bool list_item_init
Definition: uistate.h:126
bool list_item_filter_active
Definition: uistate.h:123
std::string list_item_filter
Definition: uistate.h:119
bool list_item_priority_active
Definition: uistate.h:125
std::string list_item_downvote
Definition: uistate.h:120
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
temperature_flag
Definition: enums.h:42
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const std::optional< tripoint > &trail_start, const std::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3070
uistatedata uistate
Definition: game.cpp:284
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:6996
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, point p, const std::string &text)
void wprintw(const window &win, const std::string &text)
temperature_flag temperature_flag_for_location(const map &m, const item_location &loc)
Definition: rot.cpp:12
quantity< int, temperature_in_millidegree_celsius_tag > temperature
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, point pos, int height, int width)
Definition: output.cpp:524
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void trim_and_print(const catacurses::window &w, point begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, point offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, map_item_stack::example_item_pos, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), rot::temperature_flag_for_location(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7220 of file game.cpp.

7221{
7222 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7223 // whole reality bubble
7224 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7225
7226 if( mons.empty() && items.empty() ) {
7227 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7228 return;
7229 }
7230
7231 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7232 const auto att_lhs = lhs->attitude_to( u );
7233 const auto att_rhs = rhs->attitude_to( u );
7234
7235 return att_lhs < att_rhs || ( att_lhs == att_rhs
7236 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7237 } );
7238
7239 // If the current list is empty, switch to the non-empty list
7241 if( items.empty() ) {
7242 uistate.vmenu_show_items = false;
7243 }
7244 } else if( mons.empty() ) {
7246 }
7247
7250 while( true ) {
7251 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7254 } else {
7255 break;
7256 }
7257 }
7258
7259 if( ret == game::vmenu_ret::FIRE ) {
7261 }
7263}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7715
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7265
vmenu_ret
Definition: game.h:768
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:6919
void temp_exit_fullscreen()
Definition: game.cpp:453
void reenter_fullscreen()
Definition: game.cpp:463
bool vmenu_show_items
Definition: uistate.h:122

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:721
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:214
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:193
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:183
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:178
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:188
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, point begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
#define BORDER_COLOR
Definition: output.h:92
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7715 of file game.cpp.

7716{
7717 const int iInfoHeight = 15;
7718 const int width = 45;
7719 int offsetX = 0;
7720 int iMaxRows = 0;
7721
7722 catacurses::window w_monsters;
7723 catacurses::window w_monsters_border;
7724 catacurses::window w_monster_info;
7725 catacurses::window w_monster_info_border;
7726
7727 Creature *cCurMon = nullptr;
7728 tripoint iActivePos;
7729
7730 bool hide_ui = false;
7731
7732 ui_adaptor ui;
7733 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7734 if( hide_ui ) {
7735 ui.position( point_zero, point_zero );
7736 } else {
7737 offsetX = TERMX - width;
7738 iMaxRows = TERMY - iInfoHeight - 1;
7739
7740 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
7741 1 ) );
7742 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
7743 0 ) );
7744 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
7745 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
7746 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
7747 TERMY - iInfoHeight ) );
7748
7749 if( cCurMon ) {
7750 centerlistview( iActivePos, width );
7751 }
7752
7753 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7754 }
7755 } );
7756 ui.mark_resize();
7757
7758 const int max_gun_range = u.weapon.gun_range( &u );
7759
7760 const tripoint stored_view_offset = u.view_offset;
7762
7763 int iActive = 0; // monster index that we're looking at
7764
7765 std::string action;
7766 input_context ctxt( "LIST_MONSTERS" );
7767 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7768 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7769 ctxt.register_action( "NEXT_TAB" );
7770 ctxt.register_action( "PREV_TAB" );
7771 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
7772 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
7773 ctxt.register_action( "QUIT" );
7774 if( bVMonsterLookFire ) {
7775 ctxt.register_action( "look" );
7776 ctxt.register_action( "fire" );
7777 }
7778 ctxt.register_action( "HELP_KEYBINDINGS" );
7779
7780 // first integer is the row the attitude category string is printed in the menu
7781 std::map<int, Creature::Attitude> mSortCategory;
7782
7783 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
7784 const auto attitude = monster_list[i]->attitude_to( u );
7785 if( attitude != last_attitude ) {
7786 mSortCategory[i + mSortCategory.size()] = attitude;
7787 last_attitude = attitude;
7788 }
7789 }
7790
7791 ui.on_redraw( [&]( const ui_adaptor & ) {
7792 if( !hide_ui ) {
7793 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
7794 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7795 true );
7796
7797 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
7798 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
7799
7800 if( monster_list.empty() ) {
7801 werase( w_monsters );
7802 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
7803 _( "You don't see any monsters around you!" ) );
7804 } else {
7805 werase( w_monsters );
7806
7807 const int iNumMonster = monster_list.size();
7808 const int iMenuSize = monster_list.size() + mSortCategory.size();
7809
7810 const int numw = iNumMonster > 999 ? 4 :
7811 iNumMonster > 99 ? 3 :
7812 iNumMonster > 9 ? 2 : 1;
7813
7814 // given the currently selected monster iActive. get the selected row
7815 int iSelPos = iActive;
7816 for( auto &ia : mSortCategory ) {
7817 int index = ia.first;
7818 if( index <= iSelPos ) {
7819 ++iSelPos;
7820 } else {
7821 break;
7822 }
7823 }
7824 int iStartPos = 0;
7825 // use selected row get the start row
7826 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
7827
7828 // get first visible monster and category
7829 int iCurMon = iStartPos;
7830 auto CatSortIter = mSortCategory.cbegin();
7831 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
7832 ++CatSortIter;
7833 --iCurMon;
7834 }
7835
7836 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
7837 for( int y = 0; y < endY; ++y ) {
7838 if( CatSortIter != mSortCategory.cend() ) {
7839 const int iCurPos = iStartPos + y;
7840 const int iCatPos = CatSortIter->first;
7841 if( iCurPos == iCatPos ) {
7842 const std::string cat_name = Creature::get_attitude_ui_data(
7843 CatSortIter->second ).first.translated();
7844 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
7845 ++CatSortIter;
7846 continue;
7847 }
7848 }
7849 // select current monster
7850 const auto critter = monster_list[iCurMon];
7851 const bool selected = iCurMon == iActive;
7852 ++iCurMon;
7853 if( critter->sees( g->u ) ) {
7854 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
7855 }
7856 bool is_npc = false;
7857 const monster *m = dynamic_cast<monster *>( critter );
7858 const npc *p = dynamic_cast<npc *>( critter );
7859 nc_color name_color = critter->basic_symbol_color();
7860
7861 if( selected ) {
7862 name_color = hilite( name_color );
7863 }
7864
7865 if( m != nullptr ) {
7866 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
7867 } else {
7868 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
7869 is_npc = true;
7870 }
7871
7872 if( selected && !get_safemode().empty() ) {
7873 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
7874
7875 std::string sSafemode;
7876 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
7877 sSafemode = _( "<R>emove from safemode Blacklist" );
7878 } else {
7879 sSafemode = _( "<A>dd to safemode Blacklist" );
7880 }
7881
7882 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
7883 c_white, c_light_green, sSafemode );
7884 }
7885
7887 std::string sText;
7888
7889 if( m != nullptr ) {
7890 m->get_HP_Bar( color, sText );
7891 } else {
7892 std::tie( sText, color ) =
7893 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
7894 }
7895 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
7896
7897 if( m != nullptr ) {
7898 const auto att = m->get_attitude();
7899 sText = att.first;
7900 color = att.second;
7901 } else if( p != nullptr ) {
7902 sText = npc_attitude_name( p->get_attitude() );
7903 color = p->symbol_color();
7904 }
7905 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
7906
7907 const int mon_dist = rl_dist( u.pos(), critter->pos() );
7908 const int numd = mon_dist > 999 ? 4 :
7909 mon_dist > 99 ? 3 :
7910 mon_dist > 9 ? 2 : 1;
7911
7912 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
7913 selected ? c_light_green : c_light_gray,
7914 "%*d %s",
7915 numd, mon_dist,
7916 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
7917 }
7918
7919 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
7920 iActive + 1 );
7921 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
7922
7923 werase( w_monster_info );
7924 if( cCurMon ) {
7925 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
7926 }
7927
7928 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
7929 true );
7930
7931 if( bVMonsterLookFire ) {
7932 mvwprintw( w_monster_info_border, point_east, "< " );
7933 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
7934 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
7935
7936 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
7937 wprintw( w_monster_info_border, " " );
7938 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
7939 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
7940 }
7941 wprintw( w_monster_info_border, " >" );
7942 }
7943
7944 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
7945 point_south );
7946 }
7947
7948 wnoutrefresh( w_monsters_border );
7949 wnoutrefresh( w_monster_info_border );
7950 wnoutrefresh( w_monsters );
7951 wnoutrefresh( w_monster_info );
7952 }
7953 } );
7954
7955 std::optional<tripoint> trail_start;
7956 std::optional<tripoint> trail_end;
7957 bool trail_end_x = false;
7958 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7959 trail_end_x );
7960 add_draw_callback( trail_cb );
7961
7962 do {
7963 if( action == "UP" ) {
7964 iActive--;
7965 if( iActive < 0 ) {
7966 if( monster_list.empty() ) {
7967 iActive = 0;
7968 } else {
7969 iActive = static_cast<int>( monster_list.size() ) - 1;
7970 }
7971 }
7972 } else if( action == "DOWN" ) {
7973 iActive++;
7974 if( iActive >= static_cast<int>( monster_list.size() ) ) {
7975 iActive = 0;
7976 }
7977 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7978 u.view_offset = stored_view_offset;
7980 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
7981 const auto m = dynamic_cast<monster *>( cCurMon );
7982 const std::string monName = ( m != nullptr ) ? m->name() : "human";
7983
7984 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
7986 }
7987 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
7988 if( !get_safemode().empty() ) {
7989 const auto m = dynamic_cast<monster *>( cCurMon );
7990 const std::string monName = ( m != nullptr ) ? m->name() : "human";
7991
7992 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
7994 }
7995 } else if( action == "look" ) {
7996 hide_ui = true;
7997 ui.mark_resize();
7998 look_around();
7999 hide_ui = false;
8000 ui.mark_resize();
8001 } else if( action == "fire" ) {
8002 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8003 u.last_target = shared_from( *cCurMon );
8005 u.view_offset = stored_view_offset;
8006 return game::vmenu_ret::FIRE;
8007 }
8008 }
8009
8010 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8011 cCurMon = monster_list[iActive];
8012 iActivePos = cCurMon->pos() - u.pos();
8013 centerlistview( iActivePos, width );
8014 trail_start = u.pos();
8015 trail_end = cCurMon->pos();
8016 // Actually accessed from the terrain overlay callback `trail_cb` in the
8017 // call to `ui_manager::redraw`.
8018 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8019 trail_end_x = false;
8020 } else {
8021 cCurMon = nullptr;
8022 iActivePos = tripoint_zero;
8023 u.view_offset = stored_view_offset;
8024 trail_start = trail_end = std::nullopt;
8025 }
8027
8029
8030 action = ctxt.handle_input();
8031 } while( action != "QUIT" );
8032
8033 u.view_offset = stored_view_offset;
8034
8035 return game::vmenu_ret::QUIT;
8036}
double recoil
Definition: character.h:570
nc_color symbol_color() const override
Definition: character.cpp:6020
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1893
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4575
bool bVMonsterLookFire
Definition: game.h:1034
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7357
npc_attitude get_attitude() const
Definition: npc.cpp:3164
weak_ptr_fast< Creature > last_target
Definition: player.h:241
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2565
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, point p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2543 of file game.cpp.

2544{
2547 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2550
2551 using namespace std::placeholders;
2552
2553 const std::string worldpath = get_world_base_save_path() + "/";
2554 const std::string playerpath = worldpath + name.base_path();
2555
2556 // Now load up the master game data; factions (and more?)
2557 load_master();
2558 u = avatar();
2559 u.set_save_id( name.decoded_name() );
2560 u.name = name.decoded_name();
2561 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2562 return false;
2563 }
2564
2566 u.get_avatar_diary()->load();
2567
2569
2570 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2571 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2572
2573#if defined(__ANDROID__)
2574 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2575 std::bind( &game::load_shortcuts, this, _1 ) );
2576#endif
2577
2578 // Now that the player's worn items are updated, their sight limits need to be
2579 // recalculated. (This would be cleaner if u.worn were private.)
2581
2582 if( !gamemode ) {
2583 gamemode = std::make_unique<special_game>();
2584 }
2585
2586 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2587 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2588
2589 init_autosave();
2590 get_auto_pickup().load_character(); // Load character auto pickup rules
2591 get_auto_notes_settings().load(); // Load character auto notes settings
2592 get_safemode().load_character(); // Load character safemode rules
2593 zone_manager::get_manager().load_zones(); // Load character world zones
2594 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2595 JsonIn jsin( stream );
2596 uistate.deserialize( jsin );
2597 } );
2598 reload_npcs();
2603 update_map( u );
2604 for( auto &e : u.inv_dump() ) {
2605 e->set_owner( g->u );
2606 }
2607 // legacy, needs to be here as we access the map.
2608 if( !u.getID().is_valid() ) {
2609 // player does not have a real id, so assign a new one,
2610 u.setID( assign_npc_id() );
2611 // The vehicle stores the IDs of the boarded players, so update it, too.
2612 if( u.in_vehicle ) {
2613 if( const std::optional<vpart_reference> vp = m.veh_at(
2614 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2615 vp->part().passenger_id = u.getID();
2616 }
2617 }
2618 }
2619
2620 // populate calendar caches now, after active world is set, but before we do
2621 // anything else, to ensure they pick up the correct value from the save's
2622 // worldoptions
2623 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2624 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2625
2626 u.reset();
2627
2628 return true;
2629}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:473
std::vector< item * > inv_dump()
Definition: character.cpp:8931
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1614
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3627
Definition: json.h:172
Definition: avatar.h:55
void set_save_id(const std::string &id)
Definition: avatar.h:91
void load_map_memory()
Definition: avatar.cpp:137
Helper class that fills the background and obscures all UIs below.
Definition: ui_manager.h:193
bool is_valid() const
Definition: character_id.h:19
void load()
Definition: diary.cpp:810
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1899
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:873
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:1957
void load_master()
Definition: game.cpp:2512
void validate_mounted_npcs()
Definition: game.cpp:1914
character_id assign_npc_id()
Definition: game.cpp:3564
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11252
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:1933
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:278
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), avatar::get_avatar_diary(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), diary::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), avatar::set_save_id(), calendar::set_season_length(), Character::setID(), calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), and map::veh_at().

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2519 of file game.cpp.

2520{
2521 world_generator->init();
2522 const WORLDPTR wptr = world_generator->get_world( world );
2523 if( !wptr ) {
2524 return false;
2525 }
2526 if( wptr->world_saves.empty() ) {
2527 debugmsg( "world '%s' contains no saves", world );
2528 return false;
2529 }
2530
2531 try {
2532 world_generator->set_active_world( wptr );
2533 g->setup();
2534 g->load( wptr->world_saves.front() );
2535 } catch( const std::exception &err ) {
2536 debugmsg( "cannot load world '%s': %s", world, err.what() );
2537 return false;
2538 }
2539
2540 return true;
2541}
std::vector< save_t > world_saves
Definition: worldfactory.h:62

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm,
bool  pump_events = false 
)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Parameters
pump_eventsIf true, handle window events during loading. If you set this to true, do ensure that the map is not accessed before this function returns (for example, UIs that draw the map should be disabled).

Definition at line 540 of file game.cpp.

541{
542 // TODO: fix point types
543 load_map( tripoint_abs_sm( pos_sm ), pump_events );
544}
void load_map(const tripoint &pos_sm, bool pump_events=false)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:540
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm,
bool  pump_events = false 
)

Definition at line 546 of file game.cpp.

548{
549 m.load( pos_sm, true, pump_events );
550 grid_tracker_ptr->load( m );
551}
void load(const tripoint &w, bool update_vehicles, bool pump_events=false)
Load submaps into grid.
Definition: map.cpp:6715

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2512 of file game.cpp.

2513{
2514 using namespace std::placeholders;
2515 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2516 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2517}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1193
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 811 of file game.cpp.

812{
813 const int radius = HALF_MAPSIZE - 1;
814 // uses submap coordinates
815 std::vector<shared_ptr_fast<npc>> just_added;
816 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
817 const character_id &id = temp->getID();
818 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
819 [id]( const shared_ptr_fast<npc> &n ) {
820 return n->getID() == id;
821 } );
822 if( found != active_npc.end() ) {
823 continue;
824 }
825 if( temp->is_active() ) {
826 continue;
827 }
828 if( temp->has_companion_mission() ) {
829 continue;
830 }
831
832 const tripoint sm_loc = temp->global_sm_location();
833 // NPCs who are out of bounds before placement would be pushed into bounds
834 // This can cause NPCs to teleport around, so we don't want that
835 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
836 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
837 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
838 continue;
839 }
840
841 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
842 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
843 temp->place_on_map();
844 if( !m.inbounds( temp->pos() ) ) {
845 continue;
846 }
847 // In the rare case the npc was marked for death while
848 // it was on the overmap. Kill it.
849 if( temp->marked_for_death ) {
850 temp->die( nullptr );
851 } else {
852 active_npc.push_back( temp );
853 just_added.push_back( temp );
854 }
855 }
856
857 for( const auto &npc : just_added ) {
858 npc->on_load();
859 }
860
861 npcs_dirty = false;
862}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2678
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 336 of file game.cpp.

337{
338 // UI stuff, not mod-specific per definition
339 inp_mngr.init(); // Load input config JSON
340 // Init mappings for loading the json stuff
342 fullscreen = false;
343 was_fullscreen = false;
344 show_panel_adm = false;
346
347 // These functions do not load stuff from json.
348 // The content they load/initialize is hardcoded into the program.
349 // Therefore they can be loaded here.
350 // If this changes (if they load data from json), they have to
351 // be moved to game::load_mod
352
356}
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:119
bool was_fullscreen
Definition: game.h:1016
bool fullscreen
Definition: game.h:1015
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2199
void load_global()

References fullscreen, get_auto_pickup(), get_distraction_manager(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, distraction_manager::distraction_manager_gui::load(), auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ look_around() [1/2]

std::optional< tripoint > game::look_around ( bool  force_3d = false)

Definition at line 6567 of file game.cpp.

6568{
6570 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6571 false, false, tripoint_zero, force_3d );
6572 return result.position;
6573}

References center, look_around(), Character::pos(), tripoint_zero, u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero,
bool  force_3d = false 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6575 of file game.cpp.

6578{
6579 bVMonsterLookFire = false;
6580 // TODO: Make this `true`
6581 const bool allow_zlev_move = m.has_zlevels() && ( get_option<bool>( "FOV_3D" ) || force_3d );
6582
6584
6585 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6586 int &lx = lp.x;
6587 int &ly = lp.y;
6588 int &lz = lp.z;
6589
6590 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6591 bool fast_scroll = false;
6592
6593 std::unique_ptr<ui_adaptor> ui;
6594 catacurses::window w_info;
6595 if( show_window ) {
6596 ui = std::make_unique<ui_adaptor>();
6597 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6598 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6600
6601 // If particularly small, base height on panel width irrespective of other elements.
6602 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6603 if( height < panel_width / 2 ) {
6604 height = panel_width / 2;
6605 }
6606
6607 int la_y = 0;
6608 int la_x = TERMX - panel_width;
6609 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6610 if( position == "left" ) {
6611 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6613 } else {
6614 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6615 }
6616 }
6617 int la_h = height;
6618 int la_w = panel_width;
6619 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6620
6621 ui.position_from_window( w_info );
6622 } );
6623 ui->mark_resize();
6624 }
6625
6626 std::string action;
6627 input_context ctxt( "LOOK" );
6628 ctxt.set_iso( true );
6629 ctxt.register_directions();
6630 ctxt.register_action( "COORDINATE" );
6631 ctxt.register_action( "LEVEL_UP" );
6632 ctxt.register_action( "LEVEL_DOWN" );
6633 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6634 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6635 ctxt.register_action( "SELECT" );
6636 if( peeking ) {
6637 ctxt.register_action( "throw_blind" );
6638 }
6639 if( !select_zone ) {
6640 ctxt.register_action( "TRAVEL_TO" );
6641 ctxt.register_action( "LIST_ITEMS" );
6642 }
6643 ctxt.register_action( "MOUSE_MOVE" );
6644 ctxt.register_action( "CENTER" );
6645
6646 ctxt.register_action( "debug_scent" );
6647 ctxt.register_action( "debug_scent_type" );
6648 ctxt.register_action( "debug_temp" );
6649 ctxt.register_action( "debug_visibility" );
6650 ctxt.register_action( "debug_lighting" );
6651 ctxt.register_action( "debug_radiation" );
6652 ctxt.register_action( "debug_submap_grid" );
6653 ctxt.register_action( "debug_hour_timer" );
6654 ctxt.register_action( "CONFIRM" );
6655 ctxt.register_action( "QUIT" );
6656 ctxt.register_action( "HELP_KEYBINDINGS" );
6657 if( use_tiles ) {
6658 ctxt.register_action( "zoom_out" );
6659 ctxt.register_action( "zoom_in" );
6660 }
6661#if defined(TILES)
6662 ctxt.register_action( "toggle_pixel_minimap" );
6663#endif // TILES
6664
6665 const int old_levz = get_levz();
6666 const int min_levz = force_3d ? -OVERMAP_DEPTH : std::max( old_levz - fov_3d_z_range,
6667 -OVERMAP_DEPTH );
6668 const int max_levz = force_3d ? OVERMAP_HEIGHT : std::min( old_levz + fov_3d_z_range,
6670
6671 m.update_visibility_cache( old_levz );
6673
6674 bool blink = true;
6676
6677 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6678
6679 if( show_window && ui ) {
6680 ui->on_redraw( [&]( const ui_adaptor & ) {
6681 werase( w_info );
6682 draw_border( w_info );
6683
6684 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6685
6686 std::string extended_descr_text = string_format( _( "%s - %s" ),
6687 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6688 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6689 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6690 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6691 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6692#if defined(TILES)
6693 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6694 ctxt.get_desc( "toggle_pixel_minimap" ),
6695 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6696#endif // TILES
6697
6698 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6699 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6700 fast_scroll_text );
6701#if defined(TILES)
6702 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6703 pixel_minimap_text );
6704#endif // TILES
6705
6706 int first_line = 1;
6707 const int last_line = getmaxy( w_info ) - 3;
6708 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
6709
6710 wnoutrefresh( w_info );
6711 } );
6712 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
6713 draw_look_around_cursor( lp, cache );
6714 } );
6715 add_draw_callback( ter_indicator_cb );
6716 }
6717
6718 std::optional<tripoint> zone_start;
6719 std::optional<tripoint> zone_end;
6720 bool zone_blink = false;
6721 bool zone_cursor = true;
6722 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
6723 zone_cursor, is_moving_zone );
6724 add_draw_callback( zone_cb );
6725
6726 is_looking = true;
6727 const tripoint prev_offset = u.view_offset;
6728#if defined(TILES)
6729 const int prev_tileset_zoom = tileset_zoom;
6730 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
6731 get_zoom() != 4 ) {
6732 zoom_out();
6733 }
6735#endif
6736 do {
6737 u.view_offset = center - u.pos();
6738 if( select_zone ) {
6739 if( has_first_point ) {
6740 zone_start = start_point;
6741 zone_end = lp;
6742 } else {
6743 zone_start = lp;
6744 zone_end = std::nullopt;
6745 }
6746 // Actually accessed from the terrain overlay callback `zone_cb` in the
6747 // call to `ui_manager::redraw`.
6748 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6749 zone_blink = blink;
6750 }
6751
6752 if( is_moving_zone ) {
6753 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
6754 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
6755 // Actually accessed from the terrain overlay callback `zone_cb` in the
6756 // call to `ui_manager::redraw`.
6757 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6758 zone_blink = blink;
6759 }
6762 if( ( select_zone && has_first_point ) || is_moving_zone ) {
6763 ctxt.set_timeout( get_option<int>( "BLINK_SPEED" ) );
6764 }
6765
6766 //Wait for input
6767 // only specify a timeout here if "EDGE_SCROLL" is enabled
6768 // otherwise use the previously set timeout
6769 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
6770 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
6771 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
6772 if( edge_scrolling ) {
6773 action = ctxt.handle_input( scroll_timeout );
6774 } else {
6775 action = ctxt.handle_input();
6776 }
6777 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
6778 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
6779 blink = true; // Always draw blink symbols when moving cursor
6780 } else if( action == "TIMEOUT" ) {
6781 blink = !blink;
6782 }
6783 if( action == "LIST_ITEMS" ) {
6785 } else if( action == "TOGGLE_FAST_SCROLL" ) {
6786 fast_scroll = !fast_scroll;
6787 } else if( action == "toggle_pixel_minimap" ) {
6789
6790 if( show_window && ui ) {
6791 ui->mark_resize();
6792 }
6793 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
6794 if( !allow_zlev_move ) {
6795 continue;
6796 }
6797
6798 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
6799 lz = clamp( lz + dz, min_levz, max_levz );
6800 center.z = clamp( center.z + dz, min_levz, max_levz );
6801
6802 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
6803 u.view_offset.z = center.z - u.posz();
6805 } else if( action == "TRAVEL_TO" ) {
6806 if( !u.sees( lp ) ) {
6807 add_msg( _( "You can't see that destination." ) );
6808 continue;
6809 }
6810
6811 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
6812 if( route.size() > 1 ) {
6813 route.pop_back();
6814 u.set_destination( route );
6815 } else {
6816 add_msg( m_info, _( "You can't travel there." ) );
6817 continue;
6818 }
6819 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
6821 display_scent();
6822 }
6823 } else if( action == "debug_temp" ) {
6826 }
6827 } else if( action == "debug_lighting" ) {
6830 }
6831 } else if( action == "debug_transparency" ) {
6834 }
6835 } else if( action == "debug_radiation" ) {
6838 }
6839 } else if( action == "debug_submap_grid" ) {
6840 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
6841 } else if( action == "debug_hour_timer" ) {
6843 } else if( action == "EXTENDED_DESCRIPTION" ) {
6845 } else if( action == "CENTER" ) {
6846 center = u.pos();
6847 lp = u.pos();
6848 u.view_offset.z = 0;
6849 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
6850 // This block is structured this way so that edge scroll can work
6851 // whether the mouse is moving at the edge or simply stationary
6852 // at the edge. But even if edge scroll isn't in play, there's
6853 // other things for us to do here.
6854
6855 if( edge_scrolling ) {
6856 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
6857 } else if( action == "MOUSE_MOVE" ) {
6858 const std::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
6859 if( mouse_pos ) {
6860 lx = mouse_pos->x;
6861 ly = mouse_pos->y;
6862 }
6863 }
6864 } else if( std::optional<tripoint> vec = ctxt.get_direction( action ) ) {
6865 if( fast_scroll ) {
6866 vec->x *= soffset;
6867 vec->y *= soffset;
6868 }
6869
6870 lx = lx + vec->x;
6871 ly = ly + vec->y;
6872 center.x = center.x + vec->x;
6873 center.y = center.y + vec->y;
6874 } else if( action == "throw_blind" ) {
6875 result.peek_action = PA_BLIND_THROW;
6876 } else if( action == "zoom_in" ) {
6877 center.x = lp.x;
6878 center.y = lp.y;
6879 zoom_in();
6881 } else if( action == "zoom_out" ) {
6882 center.x = lp.x;
6883 center.y = lp.y;
6884 zoom_out();
6886 }
6887 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
6888 action != "throw_blind" );
6889
6890 if( m.has_zlevels() && center.z != old_levz ) {
6891 m.invalidate_map_cache( old_levz );
6892 m.build_map_cache( old_levz );
6893 u.view_offset.z = 0;
6894 }
6895
6896 ctxt.reset_timeout();
6897 u.view_offset = prev_offset;
6898 zone_cb = nullptr;
6899 is_looking = false;
6900
6902 bVMonsterLookFire = true;
6903
6904 if( action == "CONFIRM" || action == "SELECT" ) {
6905 result.position = is_moving_zone ? zone_start : lp;
6906 }
6907
6908#if defined(TILES)
6909 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
6910 // Reset the tileset zoom to the previous value
6911 set_zoom( prev_tileset_zoom );
6913 }
6914#endif
6915
6916 return result;
6917}
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2084
void set_zoom(int level)
Definition: game.cpp:7074
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5675
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6554
int get_zoom() const
Definition: game.cpp:7086
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5750
void invalidate_map_cache(const int zlev)
Definition: map.cpp:8919
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2167
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const std::optional< tripoint > &zone_start, const std::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3023
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

std::optional< tripoint > game::look_debug ( )

Definition at line 5668 of file game.cpp.

5669{
5670 editmap edit;
5671 return edit.edit();
5672}
std::optional< tripoint > edit()
Definition: editmap.cpp:340

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 2980 of file game.cpp.

2981{
2983 if( ui ) {
2984 ui->mark_resize();
2985 }
2986}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 2722 of file game.cpp.

2723{
2724 return *memorial_logger_ptr;
2725}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 3671 of file game.cpp.

3672{
3673 const monster_visible_info &mon_visible = u.get_mon_visible();
3674 const auto &unique_types = mon_visible.unique_types;
3675 const auto &unique_mons = mon_visible.unique_mons;
3676 const auto &dangerous = mon_visible.dangerous;
3677
3678 const int width = getmaxx( w ) - 2 * hor_padding;
3679 const int maxheight = getmaxy( w );
3680
3681 const int startrow = 0;
3682
3683 // Print the direction headings
3684 // Reminder:
3685 // 7 0 1 unique_types uses these indices;
3686 // 6 8 2 0-7 are provide by direction_from()
3687 // 5 4 3 8 is used for local monsters (for when we explain them below)
3688
3689 const std::array<std::string, 8> dir_labels = {{
3690 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
3691 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
3692 }
3693 };
3694 std::array<int, 8> widths;
3695 for( int i = 0; i < 8; i++ ) {
3696 widths[i] = utf8_width( dir_labels[i] );
3697 }
3698 std::array<int, 8> xcoords;
3699 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
3700 xcoords[0] = xcoords[4] = width / 3;
3701 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
3702 xcoords[5] = xcoords[6] = xcoords[7] = 0;
3703 //for the alignment of the 1,2,3 rows on the right edge
3704 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
3705 for( int i = 0; i < 8; i++ ) {
3706 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
3707 : ( dangerous[i] ? c_light_red : c_light_gray );
3708 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
3709 }
3710
3711 // Print the symbols of all monsters in all directions.
3712 for( int i = 0; i < 8; i++ ) {
3713 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
3714
3715 // The list of symbols needs a space on each end.
3716 int symroom = ( width / 3 ) - widths[i] - 2;
3717 const int typeshere_npc = unique_types[i].size();
3718 const int typeshere_mon = unique_mons[i].size();
3719 const int typeshere = typeshere_mon + typeshere_npc;
3720 for( int j = 0; j < typeshere && j < symroom; j++ ) {
3721 nc_color c;
3722 std::string sym;
3723 if( symroom < typeshere && j == symroom - 1 ) {
3724 // We've run out of room!
3725 c = c_white;
3726 sym = "+";
3727 } else if( j < typeshere_npc ) {
3728 switch( unique_types[i][j]->get_attitude() ) {
3729 case NPCATT_KILL:
3730 c = c_red;
3731 break;
3732 case NPCATT_FOLLOW:
3733 c = c_light_green;
3734 break;
3735 default:
3736 c = c_pink;
3737 break;
3738 }
3739 sym = "@";
3740 } else {
3741 const mtype &mt = *unique_mons[i][j - typeshere_npc].first;
3742 c = mt.color;
3743 sym = mt.sym;
3744 }
3745 mvwprintz( w, pr, c, sym );
3746
3747 pr.x++;
3748 }
3749 }
3750
3751 // Now we print their full names!
3752 struct nearest_loc_and_cnt {
3753 int nearest_loc;
3754 int cnt;
3755 };
3756 std::map<const mtype *, nearest_loc_and_cnt> all_mons;
3757 for( int loc = 0; loc < 9; loc++ ) {
3758 for( const std::pair<const mtype *, int> &mon : unique_mons[loc] ) {
3759 const auto mon_it = all_mons.find( mon.first );
3760 if( mon_it == all_mons.end() ) {
3761 all_mons.emplace( mon.first, nearest_loc_and_cnt{ loc, mon.second } );
3762 } else {
3763 // 8 being the nearest location (local monsters)
3764 mon_it->second.nearest_loc = std::max( mon_it->second.nearest_loc, loc );
3765 mon_it->second.cnt += mon.second;
3766 }
3767 }
3768 }
3769 std::vector<std::pair<const mtype *, int>> mons_at[9];
3770 for( const std::pair<const mtype *const, nearest_loc_and_cnt> &mon : all_mons ) {
3771 mons_at[mon.second.nearest_loc].emplace_back( mon.first, mon.second.cnt );
3772 }
3773
3774 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
3775 // is blank.
3776 point pr( hor_padding, 4 + startrow );
3777
3778 // Print monster names, starting with those at location 8 (nearby).
3779 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
3780 // Separate names by some number of spaces (more for local monsters).
3781 int namesep = ( j == 8 ? 2 : 1 );
3782 for( const std::pair<const mtype *, int> &mon : mons_at[j] ) {
3783 const mtype *const type = mon.first;
3784 const int count = mon.second;
3785 if( pr.y >= maxheight ) {
3786 // no space to print to anyway
3787 break;
3788 }
3789
3790 const mtype &mt = *type;
3791 std::string name = mt.nname( count );
3792 // Some languages don't have plural forms, but we want to always
3793 // omit 1.
3794 if( count != 1 ) {
3795 name = string_format( pgettext( "monster count and name", "%1$d %2$s" ),
3796 count, name );
3797 }
3798
3799 // Move to the next row if necessary. (The +2 is for the "Z ").
3800 if( pr.x + 2 + utf8_width( name ) >= width ) {
3801 pr.y++;
3802 pr.x = hor_padding;
3803 }
3804
3805 if( pr.y < maxheight ) { // Don't print if we've overflowed
3806 mvwprintz( w, pr, mt.color, mt.sym );
3807 pr.x += 2; // symbol and space
3808 nc_color danger = c_dark_gray;
3809 if( mt.difficulty >= 30 ) {
3810 danger = c_red;
3811 } else if( mt.difficulty >= 16 ) {
3812 danger = c_light_red;
3813 } else if( mt.difficulty >= 8 ) {
3814 danger = c_white;
3815 } else if( mt.agro > 0 ) {
3816 danger = c_light_gray;
3817 }
3818 mvwprintz( w, pr, danger, name );
3819 pr.x += utf8_width( name ) + namesep;
3820 }
3821 }
3822 }
3823}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< std::pair< const mtype *, int > > unique_mons[9]
Definition: avatar.h:48
bool dangerous[8]
Definition: avatar.h:51
std::vector< npc * > unique_types[9]
Definition: avatar.h:47
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:256
nc_color color
Definition: mtype.h:261
int difficulty
Definition: mtype.h:267
int agro
e.g.
Definition: mtype.h:272

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, detail::count(), monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, pgettext(), string_format(), mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 3825 of file game.cpp.

3826{
3827 int newseen = 0;
3828 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
3829 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
3830 safe_proxy_dist;
3831
3832 monster_visible_info &mon_visible = u.get_mon_visible();
3833 auto &new_seen_mon = mon_visible.new_seen_mon;
3834 auto &unique_types = mon_visible.unique_types;
3835 auto &unique_mons = mon_visible.unique_mons;
3836 auto &dangerous = mon_visible.dangerous;
3837
3838 // 7 0 1 unique_types uses these indices;
3839 // 6 8 2 0-7 are provide by direction_from()
3840 // 5 4 3 8 is used for local monsters (for when we explain them below)
3841 for( auto &t : unique_types ) {
3842 t.clear();
3843 }
3844 for( auto &m : unique_mons ) {
3845 m.clear();
3846 }
3847 std::fill( dangerous, dangerous + 8, false );
3848
3849 const tripoint view = u.pos() + u.view_offset;
3850 new_seen_mon.clear();
3851
3852 // TODO: no reason to have it static here
3853 static time_point previous_turn = calendar::start_of_cataclysm;
3854 const time_duration sm_ignored_time = time_duration::from_turns(
3855 get_option<int>( "SAFEMODEIGNORETURNS" ) );
3856
3858 monster *m = dynamic_cast<monster *>( c );
3859 npc *p = dynamic_cast<npc *>( c );
3860 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
3861 const int mx = POSX + ( c->posx() - view.x );
3862 const int my = POSY + ( c->posy() - view.y );
3863 int index = 8;
3864 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
3865 // for compatibility with old code, see diagram below, it explains the values for index,
3866 // also might need revisiting one z-levels are in.
3867 switch( dir_to_mon ) {
3871 index = 7;
3872 break;
3874 case direction::NORTH:
3876 index = 0;
3877 break;
3881 index = 1;
3882 break;
3884 case direction::WEST:
3886 index = 6;
3887 break;
3889 case direction::CENTER:
3891 index = 8;
3892 break;
3894 case direction::EAST:
3896 index = 2;
3897 break;
3901 index = 5;
3902 break;
3904 case direction::SOUTH:
3906 index = 4;
3907 break;
3911 index = 3;
3912 break;
3913 }
3914 }
3915
3916 rule_state safemode_state = RULE_NONE;
3917 const bool safemode_empty = get_safemode().empty();
3918
3919 if( m != nullptr ) {
3920 //Safemode monster check
3921 monster &critter = *m;
3922
3923 const monster_attitude matt = critter.attitude( &u );
3924 const int mon_dist = rl_dist( u.pos(), critter.pos() );
3925 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
3926
3927 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
3928 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
3929 if( index < 8 && critter.sees( g->u ) ) {
3930 dangerous[index] = true;
3931 }
3932
3933 if( !safemode_empty || mon_dist <= iProxyDist ) {
3934 bool passmon = false;
3935 if( critter.ignoring > 0 ) {
3936 if( safe_mode != SAFE_MODE_ON ) {
3937 critter.ignoring = 0;
3938 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
3939 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
3940 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
3941 passmon = true;
3942 }
3943 critter.lastseen_turn = calendar::turn;
3944 }
3945
3946 if( !passmon ) {
3947 newseen++;
3948 new_seen_mon.push_back( shared_from( critter ) );
3949 }
3950 }
3951 }
3952
3953 std::vector<std::pair<const mtype *, int>> &vec = unique_mons[index];
3954 const auto mon_it = std::find_if( vec.begin(), vec.end(),
3955 [&]( const std::pair<const mtype *, int> &elem ) {
3956 return elem.first == critter.type;
3957 } );
3958 if( mon_it == vec.end() ) {
3959 vec.emplace_back( critter.type, 1 );
3960 } else {
3961 mon_it->second++;
3962 }
3963 } else if( p != nullptr ) {
3964 //Safe mode NPC check
3965
3966 const int npc_dist = rl_dist( u.pos(), p->pos() );
3967 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
3968 npc_dist );
3969
3970 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
3971 p->get_attitude() == NPCATT_KILL ) ) {
3972 if( !safemode_empty || npc_dist <= iProxyDist ) {
3973 newseen++;
3974 }
3975 }
3976 unique_types[index].push_back( p );
3977 }
3978 }
3979
3980 if( newseen > mostseen ) {
3981 if( newseen - mostseen == 1 ) {
3982 if( !new_seen_mon.empty() ) {
3983 monster &critter = *new_seen_mon.back();
3985 string_format( _( "%s spotted!" ), critter.name() ) );
3986 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
3987 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
3989 u.add_effect( effect_adrenaline_mycus, 30_minutes );
3990 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
3991 // Triffids present. We ain't got TIME to adrenaline comedown!
3992 u.add_effect( effect_adrenaline_mycus, 15_minutes );
3993 u.mod_pain( 3 ); // Does take it out of you, though
3994 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
3995 }
3996 }
3997 } else {
3998 //Hostile NPC
4000 _( "Hostile survivor spotted!" ) );
4001 }
4002 } else {
4004 }
4006 if( safe_mode == SAFE_MODE_ON ) {
4008 }
4009 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4010 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4011 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4012 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4014 add_msg( m_info, _( "Safe mode ON!" ) );
4015 }
4016 }
4017
4018 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4020 }
4021
4022 previous_turn = calendar::turn;
4023 mostseen = newseen;
4024}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1270
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:204
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1705
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1095
std::optional< time_point > lastseen_turn
Definition: monster.h:505
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2093
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
bool is_valid_in_w_terrain(point p)
Definition: game.cpp:286
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:55
@ MATT_FOLLOW
Definition: monster.h:61
@ MATT_ATTACK
Definition: monster.h:62
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, Character::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4061 of file game.cpp.

4062{
4063 cleanup_dead();
4064
4065 for( monster &critter : all_monsters() ) {
4066 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4067 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4068 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4069 critter.pos().to_string(), m.tername( critter.pos() ) );
4070 dbg( DL::Error ) << msg;
4071 add_msg( m_debug, msg );
4072 bool okay = false;
4073 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4074 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4075 critter.setpos( dest );
4076 okay = true;
4077 break;
4078 }
4079 }
4080 if( !okay ) {
4081 // die of "natural" cause (overpopulation is natural)
4082 critter.die( nullptr );
4083 }
4084 }
4085
4086 if( !critter.is_dead() ) {
4087 critter.process_items();
4088 }
4089
4090 if( !critter.is_dead() ) {
4091 critter.process_turn();
4092 }
4093
4094 m.creature_in_field( critter );
4095 if( calendar::once_every( 1_days ) ) {
4096 if( critter.has_flag( MF_MILKABLE ) ) {
4097 critter.refill_udders();
4098 }
4099 critter.try_reproduce();
4100 }
4101 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4102 critter.made_footstep = false;
4103 // Controlled critters don't make their own plans
4104 if( !critter.has_effect( effect_ai_controlled ) ) {
4105 // Formulate a path to follow
4106 critter.plan();
4107 }
4108 critter.move(); // Move one square, possibly hit u
4109 critter.process_triggers();
4110 m.creature_in_field( critter );
4111 }
4112
4113 const bionic_id bio_alarm( "bio_alarm" );
4114 if( !critter.is_dead() &&
4115 u.has_active_bionic( bio_alarm ) &&
4116 u.get_power_level() >= bio_alarm->power_trigger &&
4117 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4118 !critter.is_hallucination() ) {
4119 u.mod_power_level( -bio_alarm->power_trigger );
4120 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4122 _( "Your motion alarm goes off!" ) );
4123 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4124 u.wake_up();
4125 }
4126 }
4127 }
4128
4129 cleanup_dead();
4130
4131 // The remaining monsters are all alive, but may be outside of the reality bubble.
4132 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4133 // monster::die function is not called.
4134 for( monster &critter : all_monsters() ) {
4135 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4136 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4137 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4138 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4139 despawn_monster( critter );
4140 }
4141 }
4142
4143 // Now, do active NPCs.
4144 for( npc &guy : g->all_npcs() ) {
4145 int turns = 0;
4146 if( guy.is_mounted() ) {
4147 guy.check_mount_is_spooked();
4148 }
4149 m.creature_in_field( guy );
4150 if( !guy.has_effect( effect_npc_suspend ) ) {
4151 guy.process_turn();
4152 }
4153 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4154 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4155 ) {
4156 int moves = guy.moves;
4157 guy.move();
4158 if( moves == guy.moves ) {
4159 // Count every time we exit npc::move() without spending any moves.
4160 turns++;
4161 }
4162
4163 // Turn on debug mode when in infinite loop
4164 // It has to be done before the last turn, otherwise
4165 // there will be no meaningful debug output.
4166 if( turns == 9 ) {
4167 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4168 guy.name );
4169 debug_mode = true;
4170 }
4171 }
4172
4173 // If we spun too long trying to decide what to do (without spending moves),
4174 // Invoke cognitive suspension to prevent an infinite loop.
4175 if( turns == 10 ) {
4176 add_msg( _( "%s faints!" ), guy.name );
4177 guy.reboot();
4178 }
4179
4180 if( !guy.is_dead() ) {
4181 guy.npc_update_body();
4182 }
4183 }
4184 cleanup_dead();
4185}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1909
units::energy get_power_level() const
Definition: character.cpp:1889
void wake_up()
Definition: avatar.cpp:958
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), alert, all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), calendar::once_every(), map::points_in_radius(), Character::pos(), bionic_data::power_trigger, rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2031 of file game.cpp.

2033{
2034 const int rate = get_option<int>( "EDGE_SCROLL" );
2035 auto ret = std::make_pair( tripoint_zero, last );
2036 if( rate == -1 ) {
2037 // Fast return when the option is disabled.
2038 return ret;
2039 }
2040 // Ensure the parameters are used even if the #if below is false
2041 ( void ) ctxt;
2042 ( void ) speed;
2043 ( void ) iso;
2044#if (defined TILES || defined _WIN32 || defined WINDOWS)
2045 auto now = std::chrono::steady_clock::now();
2046 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2047 return ret;
2048 } else {
2050 }
2051 const input_event event = ctxt.get_raw_input();
2052 if( event.type == CATA_INPUT_MOUSE ) {
2053 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2054 if( event.mouse_pos.x <= threshold.x ) {
2055 ret.first.x -= speed;
2056 if( iso ) {
2057 ret.first.y -= speed;
2058 }
2059 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2060 ret.first.x += speed;
2061 if( iso ) {
2062 ret.first.y += speed;
2063 }
2064 }
2065 if( event.mouse_pos.y <= threshold.y ) {
2066 ret.first.y -= speed;
2067 if( iso ) {
2068 ret.first.x += speed;
2069 }
2070 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2071 ret.first.y += speed;
2072 if( iso ) {
2073 ret.first.x -= speed;
2074 }
2075 }
2076 ret.second = ret.first;
2077 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2078 ret.first = ret.second;
2079 }
2080#endif
2081 return ret;
2082}
@ CATA_INPUT_TIMEOUT
Definition: input.h:77
@ CATA_INPUT_MOUSE
Definition: input.h:80

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2093 of file game.cpp.

2094{
2095 // overmap has no iso mode
2099 return ret.first;
2100}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2031
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1068
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1069

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2084 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2474 of file game.cpp.

2475{
2476 const std::string save_dir = get_world_base_save_path();
2477 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2478 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2479 const std::string &prefix = base64_encode( u.get_save_id() ) + ".";
2480
2481 if( !assure_dir_exist( graveyard_dir ) ) {
2482 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2483 }
2484
2485 if( !assure_dir_exist( graveyard_save_dir ) ) {
2486 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2487 }
2488
2489 const auto save_files = get_files_from_path( prefix, save_dir );
2490 if( save_files.empty() ) {
2491 debugmsg( "could not find save files in '%s'", save_dir );
2492 }
2493
2494 for( const auto &src_path : save_files ) {
2495 const std::string dst_path = graveyard_save_dir +
2496 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2497
2498 if( rename_file( src_path, dst_path ) ) {
2499 continue;
2500 }
2501
2502 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2503
2504 if( remove_file( src_path ) ) {
2505 continue;
2506 }
2507
2508 debugmsg( "could not remove file '%s'", src_path );
2509 }
2510}
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:366
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), avatar::get_save_id(), get_world_base_save_path(), PATH_INFO::graveyarddir(), prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5135 of file game.cpp.

5136{
5137 const optional_vpart_position vp = m.veh_at( u.pos() );
5138 if( !vp ) {
5139 debugmsg( "Tried to exit non-existent vehicle." );
5140 return;
5141 }
5142 vehicle *const veh = &vp->vehicle();
5143 if( u.pos() == dest_loc ) {
5144 debugmsg( "Need somewhere to dismount towards." );
5145 return;
5146 }
5147 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5148 // TODO:: make dir() const correct!
5149 const units::angle d = ray.dir();
5150 add_msg( _( "You dive from the %s." ), veh->name );
5151 m.unboard_vehicle( u.pos() );
5152 u.moves -= 200;
5153 // Dive three tiles in the direction of tox and toy
5154 fling_creature( &u, d, 30, true );
5155 // Hit the ground according to vehicle speed
5156 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5157 if( veh->velocity > 0 ) {
5158 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5159 } else {
5160 fling_creature( &u, veh->face.dir() + 180_degrees,
5161 -( veh->velocity ) / static_cast<float>( 100 ) );
5162 }
5163 }
5164}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false)
Flings the input creature in the given direction.
Definition: game.cpp:9751

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3490 of file game.cpp.

3491{
3492 // ignore while underground or above limits
3493 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3494 return LIGHT_AMBIENT_MINIMAL;
3495 }
3496
3497 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3498 // Already found the light level for now?
3499 return latest_lightlevels[zlev];
3500 }
3501
3502 float ret = LIGHT_AMBIENT_MINIMAL;
3503
3504 // Sunlight/moonlight related stuff
3506 if( !weather.lightning_active ) {
3508 } else {
3509 // Recent lightning strike has lit the area
3511 }
3512
3514
3515 // Artifact light level changes here. Even though some of these only have an effect
3516 // aboveground it is cheaper performance wise to simply iterate through the entire
3517 // list once instead of twice.
3518 float mod_ret = -1;
3519 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3520 // will trump a lower one.
3521 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3522 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3523 const time_duration left = e->when - calendar::turn;
3524 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3525 if( left > 25_turns ) {
3526 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3527 // and the last 25 scale back towards normal.
3528 } else {
3529 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3530 }
3531 }
3533 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3534 mod_ret = std::max<float>( ret, default_daylight_level() );
3535 }
3536 // If we had a changed light level due to an artifact event then it overwrites
3537 // the natural light level.
3538 if( mod_ret > -1 ) {
3539 ret = mod_ret;
3540 }
3541
3542 // Cap everything to our minimum light level
3543 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3544
3545 latest_lightlevels[zlev] = ret;
3546
3547 return ret;
3548}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1041
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5266 of file game.cpp.

5267{
5268 enum choices : int {
5269 talk = 0,
5270 swap_pos,
5271 push,
5272 examine_wounds,
5273 use_item,
5274 sort_armor,
5275 attack,
5276 disarm,
5277 steal
5278 };
5279
5280 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5281
5282 uilist amenu;
5283
5284 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5285 amenu.addentry( talk, true, 't', _( "Talk" ) );
5286 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5287 !u.is_mounted(), 's', _( "Swap positions" ) );
5288 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5289 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5290 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5291 amenu.addentry( sort_armor, obeys, 'r', _( "Sort armor" ) );
5292 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5293 if( !who.is_player_ally() ) {
5294 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5295 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5296 }
5297
5298 amenu.query();
5299
5300 const int choice = amenu.ret;
5301 if( choice == talk ) {
5302 who.talk_to_u();
5303 } else if( choice == swap_pos ) {
5304 if( !prompt_dangerous_tile( who.pos() ) ) {
5305 return true;
5306 }
5307 // TODO: Make NPCs protest when displaced onto dangerous crap
5308 add_msg( _( "You swap places with %s." ), who.name );
5309 swap_critters( u, who );
5310 // TODO: Make that depend on stuff
5311 u.mod_moves( -200 );
5312 } else if( choice == push ) {
5313 // TODO: Make NPCs protest when displaced onto dangerous crap
5314 tripoint oldpos = who.pos();
5315 who.move_away_from( u.pos(), true );
5316 u.mod_moves( -20 );
5317 if( oldpos != who.pos() ) {
5318 add_msg( _( "%s moves out of the way." ), who.name );
5319 } else {
5320 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5321 }
5322 } else if( choice == examine_wounds ) {
5323 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5324
5325 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5326 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5327 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5328 0.0f, 0.0f );
5329 } else if( choice == use_item ) {
5330 static const std::string heal_string( "heal" );
5331 const auto will_accept = []( const item & it ) {
5332 const auto use_fun = it.get_use( heal_string );
5333 if( use_fun == nullptr ) {
5334 return false;
5335 }
5336
5337 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5338
5339 return actor != nullptr &&
5340 actor->limb_power >= 0 &&
5341 actor->head_power >= 0 &&
5342 actor->torso_power >= 0;
5343 };
5344 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5345
5346 if( !loc ) {
5347 add_msg( _( "Never mind" ) );
5348 return false;
5349 }
5350 item &used = *loc;
5351 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5352 if( did_use ) {
5353 // Note: exiting a body part selection menu counts as use here
5354 u.mod_moves( -300 );
5355 }
5356 } else if( choice == sort_armor ) {
5357 show_armor_layers_ui( who );
5358 u.mod_moves( -100 );
5359 } else if( choice == attack ) {
5360 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5361 u.melee_attack( who, true );
5362 who.on_attacked( u );
5363 }
5364 } else if( choice == disarm ) {
5365 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5367 }
5368 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5370 }
5371
5372 return true;
5373}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5729
bool in_sleep_state() const override
Definition: character.cpp:9292
void melee_attack(Creature &t, bool allow_special, const matec_id *force_technique=nullptr, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:387
int per_cur
Definition: character.h:266
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8691
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:4761
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1012
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:733
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1457
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2531
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
void try_disarm_npc(avatar &you, npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2321
void try_steal_from_npc(avatar &you, npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2397
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:610

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, show_armor_layers_ui(), skill_firstaid, game_menus::inv::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), avatar_funcs::try_disarm_npc(), avatar_funcs::try_steal_from_npc(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 4707 of file game.cpp.

4708{
4709 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
4710}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 9709 of file game.cpp.

9710{
9711 // TODO: Move this to a character method
9712 if( !u.is_mounted() ) {
9713 const item muscle( "muscle" );
9714 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
9715 if( u.has_active_bionic( bid ) ) {// active power gen
9716 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
9717 } else if( u.has_bionic( bid ) ) {// passive power gen
9718 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
9719 }
9720 }
9721 const bionic_id bio_jointservo( "bio_jointservo" );
9723 if( u.movement_mode_is( CMM_RUN ) ) {
9725 } else {
9727 }
9728 }
9729 }
9730
9731 if( u.movement_mode_is( CMM_RUN ) ) {
9732 if( !u.can_run() ) {
9734 }
9735 }
9736
9737 // apply martial art move bonuses
9738 u.martial_arts_data->ma_onmove_effects( u );
9739
9741}
static const bionic_id bio_jointservo("bio_jointservo")
@ CMM_RUN
Definition: character.h:109
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1254
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1544
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1850
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1799
void do_ambient()
Definition: sounds.cpp:1614
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32
units::energy power_trigger
Power cost when the bionic's special effect is triggered.
Definition: bionics.h:43

References bio_jointservo, Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), bionic_data::power_trigger, avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 9743 of file game.cpp.

9744{
9745#if defined(TILES)
9746 tilecontext->on_options_changed();
9747#endif
9748 grid_tracker_ptr->on_options_changed();
9749}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1495 of file handle_action.cpp.

1496{
1497 uilist as_m;
1498
1499 as_m.text = _( "What do you want to consume?" );
1500
1501 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1502 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1503 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1504 as_m.query();
1505
1506 switch( as_m.ret ) {
1507 case 0:
1509 break;
1510 case 1:
1512 break;
1513 case 2:
1515 break;
1516 default:
1517 break;
1518 }
1519}
std::vector< uilist_entry > entries
Definition: ui.h:323
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4187 of file game.cpp.

4188{
4189 std::vector<npc *> travelling_npcs;
4190 static constexpr int move_search_radius = 600;
4191 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4192 if( !elem ) {
4193 continue;
4194 }
4195 npc *npc_to_add = elem.get();
4196 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4197 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4198 travelling_npcs.push_back( npc_to_add );
4199 }
4200 }
4201 for( auto &elem : travelling_npcs ) {
4202 if( elem->has_omt_destination() ) {
4203 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4204 //recalculate path, we got distracted doing something else probably
4205 elem->omt_path.clear();
4206 }
4207 if( elem->omt_path.empty() ) {
4208 const tripoint_abs_omt &from = elem->global_omt_location();
4209 const tripoint_abs_omt &to = elem->goal;
4210 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4212 if( elem->omt_path.empty() ) {
4213 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4214 elem->get_name(), from.to_string(), to.to_string() );
4215 elem->goal = npc::no_goal_point;
4216 elem->mission = NPC_MISSION_NULL;
4217 }
4218 } else {
4219 if( elem->omt_path.back() == elem->global_omt_location() ) {
4220 elem->omt_path.pop_back();
4221 }
4222 // TODO: fix point types
4223 elem->travel_overmap(
4224 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4225 }
4226 reload_npcs();
4227 }
4228 }
4229 return;
4230}
std::vector< tripoint_abs_omt > omt_path
Route for overmap scale traveling.
Definition: character.h:1812
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1299
bool is_active() const
Definition: npc.cpp:2211
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:142
@ NPC_MISSION_TRAVELLING
Definition: npc.h:154
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5626 of file game.cpp.

5627{
5628 const std::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5629 if( !p ) {
5630 return;
5631 }
5632
5633 if( p->z != 0 ) {
5634 const tripoint old_pos = u.pos();
5635 vertical_move( p->z, false, true );
5636
5637 if( old_pos != u.pos() ) {
5638 look_around();
5639 vertical_move( p->z * -1, false, true );
5640 }
5641 return;
5642 }
5643
5644 if( m.impassable( u.pos() + *p ) || m.obstructed_by_vehicle_rotation( u.pos(), u.pos() + *p ) ) {
5645 return;
5646 }
5647
5648 peek( u.pos() + *p );
5649}
std::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:984

References _, choose_direction(), map::impassable(), look_around(), m, map::obstructed_by_vehicle_rotation(), peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5651 of file game.cpp.

5652{
5653 u.moves -= 200;
5654 tripoint prev = u.pos();
5655 u.setpos( p );
5656 tripoint center = p;
5657 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5658 true );
5659 u.setpos( prev );
5660
5661 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5662 item_location loc;
5663 avatar_action::plthrow( u, loc, p );
5664 }
5666}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11039 of file game.cpp.

11040{
11041 if( !calendar::once_every( 1_hours ) ) {
11042 return;
11043 }
11044 // Create a new NPC?
11045 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11046 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11047 return;
11048 }
11049
11050 float density = get_option<float>( "NPC_DENSITY" );
11051 static constexpr int density_search_radius = 60;
11052 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11053 if( npc_num > 0.0 ) {
11054 // 100%, 80%, 64%, 52%, 41%, 33%...
11055 density *= std::pow( 0.8f, npc_num );
11056 }
11057
11058 if( !x_in_y( density, 100 ) ) {
11059 return;
11060 }
11061 bool spawn_allowed = false;
11063 int counter = 0;
11064 while( !spawn_allowed ) {
11065 if( counter >= 10 ) {
11066 return;
11067 }
11068 static constexpr int radius_spawn_range = 120;
11069 const tripoint_abs_omt u_omt = u.global_omt_location();
11070 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11071 rng( -radius_spawn_range, radius_spawn_range ) );
11072 spawn_point.z() = 0;
11073 const oter_id oter = overmap_buffer.ter( spawn_point );
11074 // shouldn't spawn on lakes or rivers.
11075 if( !is_river_or_lake( oter ) ) {
11076 spawn_allowed = true;
11077 }
11078 counter += 1;
11079 }
11080 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11081 tmp->randomize();
11082 std::string new_fac_id = "solo_";
11083 new_fac_id += tmp->name;
11084 // create a new "lone wolf" faction for this one NPC
11085 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11086 faction_id( "no_faction" ) );
11087 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11088 // adds the npc to the correct overmap.
11089 // Only spawn random NPCs on z-level 0
11090 // TODO: fix point types
11091 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11092 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11094 tmp->form_opinion( u );
11095 tmp->mission = NPC_MISSION_NULL;
11096 tmp->long_term_goal_action();
11097 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11098 tmp->getID() ) );
11099 // This will make the new NPC active- if its nearby to the player
11100 load_npcs();
11101}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(point p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 9441 of file game.cpp.

9442{
9443 if( dest_loc.z != u.posz() && !via_ramp ) {
9444 // No vertical phasing yet
9445 return false;
9446 }
9447
9448 //probability travel through walls but not water
9449 tripoint dest = dest_loc;
9450 // tile is impassable
9451 int tunneldist = 0;
9452 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
9453 while( m.impassable( dest ) ||
9454 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
9455 //add 1 to tunnel distance for each impassable tile in the line
9456 tunneldist += 1;
9457 //Being dimensionally anchored prevents quantum shenanigans.
9458 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
9460 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
9461 return false;
9462 }
9463 if( tunneldist > 24 ) {
9464 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
9465 return false;
9466 }
9467
9468 dest.x += d.x;
9469 dest.y += d.y;
9470 }
9471
9473
9474 if( tunneldist != 0 ) {
9475 // -1 because power_cost for the first tile was already taken up by the bionic's activation
9476 if( ( tunneldist - 1 ) * power_cost > u.get_power_level() ) {
9477 // oops, not enough energy! Tunneling costs set amount of bionic power per impassable tile
9478 if( tunneldist * power_cost > u.get_max_power_level() ) {
9479 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
9480 } else {
9481 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %s of bionic power to travel that thickness of material." ),
9482 units::display( power_cost * tunneldist ) );
9483 }
9484 return false;
9485 }
9486
9487 if( u.in_vehicle ) {
9488 m.unboard_vehicle( u.pos() );
9489 }
9490
9491 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
9492 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
9493 u.mod_power_level( -( ( tunneldist - 1 ) * power_cost ) );
9494 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
9495 u.moves -= ( 50 + ( tunneldist * 50 ) );
9496 u.setpos( dest );
9497
9498 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
9499 m.board_vehicle( u.pos(), &u );
9500 }
9501
9502 u.grab( OBJECT_NONE );
9504 m.creature_on_trap( u );
9505 return true;
9506 }
9507
9508 return false;
9509}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3245
units::energy get_max_power_level() const
Definition: character.cpp:1894
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1208
void on_move_effects()
Definition: game.cpp:9709
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1108
constexpr int sgn(const T x)
Definition: enums.h:8
static const bionic_id bio_probability_travel("bio_probability_travel")
std::string display(const units::energy v)
Definition: units.cpp:59
units::energy power_activate
Power cost on activation.
Definition: bionics.h:37

References _, add_msg(), player::add_msg_if_player(), bio_probability_travel, map::board_vehicle(), map::creature_on_trap(), critter_at(), units::display(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), bionic_data::power_activate, Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5597 of file game.cpp.

5598{
5599 const std::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5600 _( "There is nothing to pick up nearby." ),
5601 ACTION_PICKUP, false );
5602 if( !examp_ ) {
5603 return;
5604 }
5605 pickup( *examp_ );
5606}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5608 of file game.cpp.

5609{
5610 // Highlight target
5611 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5612 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5613 } );
5614 add_draw_callback( hilite_cb );
5615
5616 pickup::pick_up( p, 0 );
5617}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5619 of file game.cpp.

5620{
5621 pickup::pick_up( u.pos(), 1 );
5622}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4655 of file game.cpp.

4656{
4657 // TODO: change this into an assert, it must never happen.
4658 if( id.is_null() ) {
4659 return nullptr;
4660 }
4661 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4662}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4655

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4664 of file game.cpp.

4668{
4669 std::optional<tripoint> where;
4670 if( forced || can_place_monster( *mon, center ) ) {
4671 where = center;
4672 }
4673
4674 // This loop ensures the monster is placed as close to the center as possible,
4675 // but all places that equally far from the center have the same probability.
4676 for( int r = 1; r <= radius && !where; ++r ) {
4678 }
4679
4680 if( !where ) {
4681 return nullptr;
4682 }
4683 mon->spawn( *where );
4684 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4685}
static std::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4637
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4621

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4645 of file game.cpp.

4646{
4647 return place_critter_around( id, p, 0 );
4648}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4650 of file game.cpp.

4651{
4652 return place_critter_around( mon, p, 0 );
4653}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 4687 of file game.cpp.

4688{
4689 // TODO: change this into an assert, it must never happen.
4690 if( id.is_null() ) {
4691 return nullptr;
4692 }
4693 return place_critter_within( make_shared_fast<monster>( id ), range );
4694}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:4687

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 4696 of file game.cpp.

4698{
4699 const std::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
4700 if( !where ) {
4701 return nullptr;
4702 }
4703 mon->spawn( *where );
4704 return critter_tracker->add( mon ) ? mon.get() : nullptr;
4705}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9079 of file game.cpp.

9080{
9081 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9082 if( const std::optional<std::string> label = vp1.get_label() ) {
9083 add_msg( m_info, _( "Label here: %s" ), *label );
9084 }
9085 std::string signage = m.get_signage( dest_loc );
9086 if( !signage.empty() ) {
9087 if( !u.has_trait( trait_ILLITERATE ) ) {
9088 add_msg( m_info, _( "The sign says: %s" ), signage );
9089 } else {
9090 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9091 }
9092 }
9093 if( m.has_graffiti_at( dest_loc ) ) {
9094 if( !u.has_trait( trait_ILLITERATE ) ) {
9095 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9096 } else {
9097 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9098 }
9099 }
9100 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9101 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9102 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9103 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9104 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9105 dest_loc ) );
9106 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9107 }
9108 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9109 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9110 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9111 dest_loc ) );
9112 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9113 }
9114 }
9115 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9116 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9117 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9118 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9119 if( u.is_mounted() ) {
9120 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9121 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9122 } else {
9123 const bodypart_id bp = u.get_random_body_part();
9124 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9125 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9126 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9127 body_part_name_accusative( bp->token ),
9128 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9129 dest_loc ) );
9130 }
9131 }
9132 }
9133 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9134 u.add_effect( effect_bouldering, 1_turns, num_bp );
9135 } else if( u.has_effect( effect_bouldering ) ) {
9137 }
9138 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9139 u.add_effect( effect_no_sight, 1_turns, num_bp );
9140 } else if( u.has_effect( effect_no_sight ) ) {
9142 }
9143
9144 // If we moved out of the nonant, we need update our map data
9145 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9146 add_msg( _( "The water puts out the flames!" ) );
9148 if( u.is_mounted() ) {
9149 monster *mon = u.mounted_creature.get();
9150 if( mon->has_effect( effect_onfire ) ) {
9152 }
9153 }
9154 }
9155
9156 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9157 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9158 // Immobile monsters can't be displaced.
9159 monster &critter = *mon_ptr;
9160 // TODO: handling for ridden creatures other than players mount.
9161 if( !critter.has_effect( effect_ridden ) ) {
9162 if( u.is_mounted() ) {
9163 std::vector<tripoint> valid;
9164 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9165 if( is_empty( jk ) ) {
9166 valid.push_back( jk );
9167 }
9168 }
9169 if( !valid.empty() ) {
9170 critter.move_to( random_entry( valid ) );
9171 add_msg( _( "You push the %s out of the way." ), critter.name() );
9172 } else {
9173 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9174 return u.pos().xy();
9175 }
9176 } else {
9177 critter.move_to( u.pos(), false,
9178 true ); // Force the movement even though the player is there right now.
9179 add_msg( _( "You displace the %s." ), critter.name() );
9180 }
9181 } else if( !u.has_effect( effect_riding ) ) {
9182 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9183 return u.pos().xy();
9184 }
9185 }
9186
9187 // If the player is in a vehicle, unboard them from the current part
9188 if( u.in_vehicle ) {
9189 m.unboard_vehicle( u.pos() );
9190 }
9191 // Move the player
9192 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9193 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9194 vertical_shift( dest_loc.z );
9195 }
9196
9197 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9198 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9199 vp1 ) ) {
9200 u.stop_hauling();
9201 }
9202 u.setpos( dest_loc );
9203 if( u.is_mounted() ) {
9204 monster *mon = u.mounted_creature.get();
9205 mon->setpos( dest_loc );
9206 mon->process_triggers();
9207 m.creature_in_field( *mon );
9208 }
9209 point submap_shift = update_map( u );
9210 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9211 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9212 // If you must use it you can calculate the position in the new, shifted system with
9213 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9214
9215 //Auto pulp or butcher and Auto foraging
9216 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9218
9219 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9220 if( forage_type != "off" ) {
9221 const auto forage = [&]( const tripoint & pos ) {
9222 const auto &xter_t = m.ter( pos ).obj().examine;
9223 const auto &xfurn_t = m.furn( pos ).obj().examine;
9224 const bool forage_everything = forage_type == "both";
9225 const bool forage_bushes = forage_everything || forage_type == "bushes";
9226 const bool forage_trees = forage_everything || forage_type == "trees";
9227 if( xter_t == &iexamine::none && xfurn_t == &iexamine::none ) {
9228 return;
9229 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9230 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9231 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9232 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9233 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9234 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9235 ) {
9236 xter_t( u, pos );
9237 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9238 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9239 ) {
9240 xfurn_t( u, pos );
9241 }
9242 };
9243
9244 for( auto &elem : adjacentDir ) {
9245 forage( u.pos() + direction_XY( elem ) );
9246 }
9247 }
9248
9249 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9250 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9251 std::vector<item *> corpses;
9252
9253 for( item &it : m.i_at( u.pos() ) ) {
9254 corpses.push_back( &it );
9255 }
9256
9257 if( !corpses.empty() ) {
9258 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9259 for( item *it : corpses ) {
9260 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9261 }
9262 }
9263 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9264 const auto pulp = [&]( const tripoint & pos ) {
9265 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9266 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9267 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9269 u.activity.placement = m.getabs( pos );
9270 u.activity.auto_resume = true;
9271 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9272 return;
9273 }
9274 }
9275 };
9276
9277 if( pulp_butcher == "pulp_adjacent" ) {
9278 for( auto &elem : adjacentDir ) {
9279 pulp( u.pos() + direction_XY( elem ) );
9280 }
9281 } else {
9282 pulp( u.pos() );
9283 }
9284 }
9285 }
9286
9287 //Autopickup
9288 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9289 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9290 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9291 pickup::pick_up( u.pos(), -1 );
9292 }
9293
9294 // If the new tile is a boardable part, board it
9295 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9296 m.board_vehicle( u.pos(), &u );
9297 }
9298
9299 // Traps!
9300 // Try to detect.
9302 if( u.is_mounted() ) {
9304 } else {
9305 m.creature_on_trap( u );
9306 }
9307 // Drench the player if swimmable
9308 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9309 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9310 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9311 }
9312
9313 // List items here
9314 if( !m.has_flag( "SEALED", u.pos() ) ) {
9315 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9316 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9317 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9318 add_msg( _( "There's something here, but you can't see what it is." ) );
9319 } else if( m.has_items( u.pos() ) ) {
9320 std::vector<std::string> names;
9321 std::vector<size_t> counts;
9322 std::vector<item> items;
9323 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9324
9325 std::string next_tname = tmpitem.tname();
9326 std::string next_dname = tmpitem.display_name();
9327 bool by_charges = tmpitem.count_by_charges();
9328 bool got_it = false;
9329 for( size_t i = 0; i < names.size(); ++i ) {
9330 if( by_charges && next_tname == names[i] ) {
9331 counts[i] += tmpitem.charges;
9332 got_it = true;
9333 break;
9334 } else if( next_dname == names[i] ) {
9335 counts[i] += 1;
9336 got_it = true;
9337 break;
9338 }
9339 }
9340 if( !got_it ) {
9341 if( by_charges ) {
9342 names.push_back( tmpitem.tname( tmpitem.charges ) );
9343 counts.push_back( tmpitem.charges );
9344 } else {
9345 names.push_back( tmpitem.display_name( 1 ) );
9346 counts.push_back( 1 );
9347 }
9348 items.push_back( tmpitem );
9349 }
9350 if( names.size() > 10 ) {
9351 break;
9352 }
9353 }
9354 for( size_t i = 0; i < names.size(); ++i ) {
9355 if( !items[i].count_by_charges() ) {
9356 names[i] = items[i].display_name( counts[i] );
9357 } else {
9358 names[i] = items[i].tname( counts[i] );
9359 }
9360 }
9361 int and_the_rest = 0;
9362 for( size_t i = 0; i < names.size(); ++i ) {
9363 //~ number of items: "<number> <item>"
9364 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9365 names[i] = string_format( fmt, counts[i], names[i] );
9366 // Skip the first two.
9367 if( i > 1 ) {
9368 and_the_rest += counts[i];
9369 }
9370 }
9371 if( names.size() == 1 ) {
9372 add_msg( _( "You see here %s." ), names[0] );
9373 } else if( names.size() == 2 ) {
9374 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9375 } else if( names.size() == 3 ) {
9376 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9377 } else if( and_the_rest < 7 ) {
9378 add_msg( vgettext( "You see here %s, %s and %d more item.",
9379 "You see here %s, %s and %d more items.",
9380 and_the_rest ),
9381 names[0], names[1], and_the_rest );
9382 } else {
9383 add_msg( _( "You see here %s and many more items." ), names[0] );
9384 }
9385 }
9386 }
9387 }
9388
9389 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9390 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9391 add_msg( _( "There are vehicle controls here." ) );
9392 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9393 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9394 }
9395 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9396 u.is_mounted() ) {
9397 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9398 }
9399 return submap_shift;
9400}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:331
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1729
bool is_hauling() const
Definition: character.cpp:9156
void stop_hauling()
Definition: character.cpp:9147
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1641
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:10562
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6012
std::string furnname(const tripoint &p)
Definition: map.cpp:1528
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2398
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7940
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4863
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7929
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2388
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2374
void setpos(const tripoint &p) override
Definition: monster.cpp:238
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1553
void process_triggers()
Definition: monster.cpp:1221
std::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void search_surroundings(Character &who)
Search surrounding squares for traps (and maybe other things in the future).
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3681
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3646
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2118
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2097
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2106
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2088
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3660
string_id< zone_type > zone_type_id
Definition: type_id.h:202

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), character_funcs::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9402 of file game.cpp.

9403{
9404 // if player is teleporting around, they don't bring their horse with them
9405 if( u.is_mounted() ) {
9407 u.mounted_creature->remove_effect( effect_ridden );
9408 u.mounted_creature = nullptr;
9409 }
9410 // offload the active npcs.
9411 unload_npcs();
9412 for( monster &critter : all_monsters() ) {
9413 despawn_monster( critter );
9414 }
9415 if( u.in_vehicle ) {
9416 m.unboard_vehicle( u.pos() );
9417 }
9418
9420 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9421 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9422 for( int z = minz; z <= maxz; z++ ) {
9423 m.clear_vehicle_list( z );
9424 }
9426 // offset because load_map expects the coordinates of the top left corner, but the
9427 // player will be centered in the middle of the map.
9428 // TODO: fix point types
9429 const tripoint map_sm_pos(
9430 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
9431 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
9432 load_map( map_sm_pos );
9433 load_npcs();
9434 m.spawn_monsters( true ); // Static monsters
9436 // update weather now as it could be different on the new location
9438 place_player( player_pos );
9439}
point place_player(const tripoint &dest)
Definition: game.cpp:9079
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:864
void update_overmap_seen()
Definition: game.cpp:10740
level_cache & access_cache(int zlev)
Definition: map.cpp:8839
void clear_vehicle_list(int zlev)
Definition: map.cpp:390
void clear_vehicle_cache()
Definition: map.cpp:372
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:351

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 760 of file game.cpp.

763{
764 std::vector<std::string> search_types = omt_search_types;
765 if( search_types.empty() ) {
766 vehicle veh( id );
767 if( veh.can_float() ) {
768 search_types.push_back( "river" );
769 search_types.push_back( "lake" );
770 } else {
771 search_types.push_back( "field" );
772 search_types.push_back( "road" );
773 }
774 }
775 for( const std::string &search_type : search_types ) {
776 omt_find_params find_params;
777 find_params.must_see = false;
778 find_params.cant_see = false;
779 find_params.types.emplace_back( search_type, ot_match_type::type );
780 // find nearest road
781 find_params.min_distance = min_distance;
782 find_params.search_range = max_distance;
783 // if player spawns underground, park their car on the surface.
784 const tripoint_abs_omt omt_origin( origin, 0 );
785 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
786 // try place vehicle there.
787 tinymap target_map;
788 target_map.load( project_to<coords::sm>( goal ), false );
789 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
790 static constexpr std::array<units::angle, 4> angles = {{
791 0_degrees, 90_degrees, 180_degrees, 270_degrees
792 }
793 };
794 vehicle *veh = target_map.add_vehicle(
795 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
796 if( veh ) {
797 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
798 veh->sm_pos = ms_to_sm_remain( abs_local );
799 veh->pos = abs_local.xy();
801 veh->tracking_on = true;
802 target_map.save();
803 return veh;
804 }
805 }
806 }
807 return nullptr;
808}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6700
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5633
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2056
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1941
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1926
bool tracking_on
Definition: vehicle.h:2016
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6554 of file game.cpp.

6557{
6558 // get global area info according to look_around caret position
6559 // TODO: fix point types
6561 lp ) ) ) );
6562 // we only need the area name and then pass it to print_all_tile_info() function below
6563 const std::string area_name = cur_ter_m->get_name();
6564 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6565}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:5729
point ms_to_omt_copy(point p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 5729 of file game.cpp.

5734{
5735 visibility_type visibility = VIS_HIDDEN;
5736 const bool inbounds = m.inbounds( lp );
5737 if( inbounds ) {
5738 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5739 }
5740 const Creature *creature = critter_at( lp, true );
5741 switch( visibility ) {
5742 case VIS_CLEAR: {
5743 const optional_vpart_position vp = m.veh_at( lp );
5744 print_terrain_info( lp, w_look, area_name, column, line );
5745 print_fields_info( lp, w_look, column, line );
5746 print_trap_info( lp, w_look, column, line );
5747 print_creature_info( creature, w_look, column, line, last_line );
5748 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
5749 last_line );
5750 print_items_info( lp, w_look, column, line, last_line );
5751 print_graffiti_info( lp, w_look, column, line, last_line );
5752 }
5753 break;
5754 case VIS_BOOMER:
5755 case VIS_BOOMER_DARK:
5756 case VIS_DARK:
5757 case VIS_LIT:
5758 case VIS_HIDDEN:
5759 print_visibility_info( w_look, column, line, visibility );
5760
5761 if( creature != nullptr ) {
5762 std::vector<std::string> buf;
5763 if( u.sees_with_infrared( *creature ) ) {
5764 creature->describe_infrared( buf );
5765 } else if( u.sees_with_specials( *creature ) ) {
5766 creature->describe_specials( buf );
5767 }
5768 for( const std::string &s : buf ) {
5769 mvwprintw( w_look, point( 1, ++line ), s );
5770 }
5771 }
5772 break;
5773 }
5774 if( !inbounds ) {
5775 return;
5776 }
5777 auto this_sound = sounds::sound_at( lp );
5778 if( !this_sound.empty() ) {
5779 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
5780 } else {
5781 // Check other z-levels
5782 tripoint tmp = lp;
5783 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
5784 if( tmp.z == lp.z ) {
5785 continue;
5786 }
5787
5788 auto zlev_sound = sounds::sound_at( tmp );
5789 if( !zlev_sound.empty() ) {
5790 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
5791 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
5792 }
5793 }
5794 }
5795}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6336
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:5902
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:5826
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5996
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5940
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5949
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:5958
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:5797
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:5920
void line(map *m, const ter_id &type, point p1, point p2)
Definition: mapgen.cpp:6485
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5940 of file game.cpp.

5942{
5943 int vLines = last_line - line;
5944 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
5945 line = creature->print_info( w_look, ++line, vLines, column );
5946 }
5947}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 5902 of file game.cpp.

5904{
5905 const field &tmpfield = m.field_at( lp );
5906 for( auto &fld : tmpfield ) {
5907 const field_entry &cur = fld.second;
5908 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
5909 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
5910 const int max_width = getmaxx( w_look ) - column - 2;
5911 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
5912 get_fire_fuel_string( lp ) ) - 1;
5913 line += lines;
5914 } else {
5915 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
5916 }
5917 }
5918}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:627
ter_id t_pit
Definition: mapdata.cpp:627

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5996 of file game.cpp.

5999{
6000 if( line > last_line ) {
6001 return;
6002 }
6003
6004 const int max_width = getmaxx( w_look ) - column - 2;
6005 if( m.has_graffiti_at( lp ) ) {
6006 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6007 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6008 m.graffiti_at( lp ) );
6009 }
6010}
ter_id t_grave_new
Definition: mapdata.cpp:627

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5958 of file game.cpp.

5962{
5963 if( !m.sees_some_items( lp, u ) ) {
5964 return;
5965 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
5966 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
5967 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
5968 mvwprintz( w_look, point( column, ++line ), c_yellow,
5969 _( "There's something there, but you can't see what it is." ) );
5970 return;
5971 } else {
5972 std::map<std::string, int> item_names;
5973 for( auto &item : m.i_at( lp ) ) {
5974 ++item_names[item.tname()];
5975 }
5976
5977 const int max_width = getmaxx( w_look ) - column - 1;
5978 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
5979 // last line but not last item
5980 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
5981 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
5982 break;
5983 }
5984
5985 if( it->second > 1 ) {
5986 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
5987 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
5988 it->first.c_str(), it->second );
5989 } else {
5990 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
5991 }
5992 }
5993 }
5994}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4839
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 5826 of file game.cpp.

5829{
5830 const int max_width = getmaxx( w_look ) - column - 1;
5831 int lines;
5832
5833 const auto fmt_tile_info = []( const tripoint & lp ) {
5834 map &here = get_map();
5835 std::string ret;
5836 if( debug_mode ) {
5837 ret += lp.to_string();
5838 ret += "\n";
5839 }
5840 ret += here.tername( lp );
5842 ret += colorize( string_format( " [%s]", here.ter( lp )->id ), c_light_blue );
5843 }
5844 if( here.has_furn( lp ) ) {
5845 ret += string_format( "; %s", here.furnname( lp ) );
5847 ret += colorize( string_format( " [%s]", here.furn( lp )->id ), c_light_blue );
5848 }
5849 }
5850 return ret;
5851 };
5852
5853 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
5854
5855 if( m.impassable( lp ) ) {
5856 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5857 _( "%s; Impassable" ),
5858 tile );
5859 } else {
5860 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
5861 _( "%s; Movement cost %d" ),
5862 tile, m.move_cost( lp ) * 50 );
5863
5864 const auto ll = get_light_level( std::max( 1.0,
5865 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
5866 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
5867 wprintz( w_look, ll.second, ll.first );
5868 }
5869
5870 std::string signage = m.get_signage( lp );
5871 if( !signage.empty() ) {
5872 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5873 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
5874 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
5875 }
5876
5877 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
5878 // Print info about stuff below
5879 tripoint below( lp.xy(), lp.z - 1 );
5880 std::string tile_below = fmt_tile_info( below );
5881
5882 if( !m.has_floor_or_support( lp ) ) {
5883 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5884 _( "Below: %s; No support" ),
5885 tile_below );
5886 } else {
5887 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5888 _( "Below: %s; Walkable" ),
5889 tile_below );
5890 }
5891 }
5892
5893 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
5894 m.features( lp ) );
5895 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
5896 m.coverage( lp ) );
5897 if( line < lines ) {
5898 line = lines + map_features - 1;
5899 }
5900}
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2115
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:681
std::string features(const tripoint &p)
Definition: map.cpp:1773
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6349
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:500
ter_str_id id
Definition: mapdata.h:465

References _, map::ambient_light_at(), c_dark_gray, c_light_blue, c_light_gray, colorize(), map::coverage(), debug_mode, display_object_ids, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 5920 of file game.cpp.

5923{
5924 const trap &tr = m.tr_at( lp );
5925 if( tr.can_see( lp, u ) ) {
5926 partial_con *pc = m.partial_con_at( lp );
5927 std::string tr_name;
5928 if( pc && tr.loadid == tr_unfinished_construction ) {
5929 const construction &built = pc->id.obj();
5930 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.group->name(),
5931 pc->counter / 100000 );
5932 } else {
5933 tr_name = tr.name();
5934 }
5935
5936 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
5937 }
5938}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5246
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string name() const
construction_group_str_id group
Definition: construction.h:50
construction_id id
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::group, partial_con::id, line(), trap::loadid, m, mvwprintz(), construction_group::name(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 5949 of file game.cpp.

5951{
5952 if( veh ) {
5953 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
5954 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
5955 }
5956}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 5797 of file game.cpp.

5799{
5800 const char *visibility_message = nullptr;
5801 switch( visibility ) {
5802 case VIS_CLEAR:
5803 visibility_message = _( "Clearly visible." );
5804 break;
5805 case VIS_BOOMER:
5806 visibility_message = _( "A bright pink blur." );
5807 break;
5808 case VIS_BOOMER_DARK:
5809 visibility_message = _( "A pink blur." );
5810 break;
5811 case VIS_DARK:
5812 visibility_message = _( "Darkness." );
5813 break;
5814 case VIS_LIT:
5815 visibility_message = _( "Bright light." );
5816 break;
5817 case VIS_HIDDEN:
5818 visibility_message = _( "Unseen." );
5819 break;
5820 }
5821
5822 mvwprintw( w_look, point( line, column ), visibility_message );
5823 line += 2;
5824}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1655 of file game.cpp.

1656{
1657 if( !u.activity ) {
1658 return;
1659 }
1660
1661 while( u.moves > 0 && u.activity ) {
1662 u.activity.do_turn( u );
1663 }
1664}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11312 of file game.cpp.

11313{
11314 const bool worn = p.is_worn( it );
11315 const bool wielded = ( &it == &p.weapon );
11316 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11317 if( worn ) {
11318 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11319 effects.insert( effects.end(), ew.begin(), ew.end() );
11320 }
11321 if( wielded ) {
11322 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11323 effects.insert( effects.end(), ew.begin(), ew.end() );
11324 }
11325
11326 if( it.is_tool() ) {
11327 // Recharge it if necessary
11328 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11329 //Before incrementing charge, check that any extra requirements are met
11330 if( check_art_charge_req( it ) ) {
11331 switch( it.type->artifact->charge_type ) {
11332 case ARTC_NULL:
11333 case NUM_ARTCS:
11334 break; // dummy entries
11335 case ARTC_TIME:
11336 // Once per hour
11337 if( calendar::once_every( 1_hours ) ) {
11338 it.charges++;
11339 }
11340 break;
11341 case ARTC_SOLAR:
11342 if( calendar::once_every( 10_minutes ) &&
11343 is_in_sunlight( p.pos() ) ) {
11344 it.charges++;
11345 }
11346 break;
11347 // Artifacts can inflict pain even on Deadened folks.
11348 // Some weird Lovecraftian thing. ;P
11349 // (So DON'T route them through mod_pain!)
11350 case ARTC_PAIN:
11351 if( calendar::once_every( 1_minutes ) ) {
11352 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11353 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11354 it.charges++;
11355 }
11356 break;
11357 case ARTC_HP:
11358 if( calendar::once_every( 1_minutes ) ) {
11359 add_msg( m_bad, _( "You feel your body decaying." ) );
11360 p.hurtall( 1, nullptr );
11361 it.charges++;
11362 }
11363 break;
11364 case ARTC_FATIGUE:
11365 if( calendar::once_every( 1_minutes ) ) {
11366 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11367 u.mod_fatigue( 3 * rng( 1, 3 ) );
11368 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11369 it.charges++;
11370 }
11371 break;
11372 // Portals are energetic enough to charge the item.
11373 // Tears in reality are consumed too, but can't charge it.
11374 case ARTC_PORTAL:
11375 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11376 m.remove_field( dest, fd_fatigue );
11377 if( m.tr_at( dest ).loadid == tr_portal ) {
11378 add_msg( m_good, _( "The portal collapses!" ) );
11379 m.remove_trap( dest );
11380 it.charges++;
11381 break;
11382 }
11383 }
11384 break;
11385 }
11386 }
11387 }
11388 }
11389
11390 for( const art_effect_passive &i : effects ) {
11391 switch( i ) {
11392 case AEP_STR_UP:
11393 p.mod_str_bonus( +4 );
11394 break;
11395 case AEP_DEX_UP:
11396 p.mod_dex_bonus( +4 );
11397 break;
11398 case AEP_PER_UP:
11399 p.mod_per_bonus( +4 );
11400 break;
11401 case AEP_INT_UP:
11402 p.mod_int_bonus( +4 );
11403 break;
11404 case AEP_ALL_UP:
11405 p.mod_str_bonus( +2 );
11406 p.mod_dex_bonus( +2 );
11407 p.mod_per_bonus( +2 );
11408 p.mod_int_bonus( +2 );
11409 break;
11410 case AEP_SPEED_UP:
11411 // Handled in player::current_speed()
11412 break;
11413
11414 case AEP_PBLUE:
11415 if( p.get_rad() > 0 ) {
11416 p.mod_rad( -1 );
11417 }
11418 break;
11419
11420 case AEP_SMOKE:
11421 if( one_in( 10 ) ) {
11422 tripoint pt( p.posx() + rng( -1, 1 ),
11423 p.posy() + rng( -1, 1 ),
11424 p.posz() );
11425 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
11426 }
11427 break;
11428
11429 case AEP_SNAKES:
11430 break; // Handled in player::hit()
11431
11432 case AEP_EXTINGUISH:
11433 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11434 m.mod_field_age( dest, fd_fire, -1_turns );
11435 }
11436 break;
11437
11438 case AEP_FUN:
11439 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
11440 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
11441 break;
11442
11443 case AEP_HUNGER:
11444 if( one_in( 100 ) ) {
11445 p.mod_stored_kcal( -10 );
11446 }
11447 break;
11448
11449 case AEP_THIRST:
11450 if( one_in( 120 ) ) {
11451 p.mod_thirst( 1 );
11452 }
11453 break;
11454
11455 case AEP_EVIL:
11456 if( one_in( 150 ) ) { // Once every 15 minutes, on average
11457 p.add_effect( effect_evil, 30_minutes );
11458 if( it.is_armor() ) {
11459 if( !worn ) {
11460 add_msg( _( "You have an urge to wear the %s." ),
11461 it.tname() );
11462 }
11463 } else if( !wielded ) {
11464 add_msg( _( "You have an urge to wield the %s." ),
11465 it.tname() );
11466 }
11467 }
11468 break;
11469
11470 case AEP_SCHIZO:
11471 break; // Handled in player::suffer()
11472
11473 case AEP_RADIOACTIVE:
11474 if( one_in( 4 ) ) {
11475 p.irradiate( 1.0f );
11476 }
11477 break;
11478
11479 case AEP_STR_DOWN:
11480 p.mod_str_bonus( -3 );
11481 break;
11482
11483 case AEP_DEX_DOWN:
11484 p.mod_dex_bonus( -3 );
11485 break;
11486
11487 case AEP_PER_DOWN:
11488 p.mod_per_bonus( -3 );
11489 break;
11490
11491 case AEP_INT_DOWN:
11492 p.mod_int_bonus( -3 );
11493 break;
11494
11495 case AEP_ALL_DOWN:
11496 p.mod_str_bonus( -2 );
11497 p.mod_dex_bonus( -2 );
11498 p.mod_per_bonus( -2 );
11499 p.mod_int_bonus( -2 );
11500 break;
11501
11502 case AEP_SPEED_DOWN:
11503 break; // Handled in player::current_speed()
11504
11505 default:
11506 //Suppress warnings
11507 break;
11508 }
11509 }
11510 // Recalculate, as it might have changed (by mod_*_bonus above)
11511 p.str_cur = p.get_str();
11512 p.int_cur = p.get_int();
11513 p.dex_cur = p.get_dex();
11514 p.per_cur = p.get_per();
11515}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4189
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4184
int str_cur
Definition: character.h:263
void mod_rad(int mod)
Definition: character.cpp:7056
virtual int get_dex() const
Definition: character.cpp:4073
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4304
bool is_worn(const item &thing) const
Definition: character.h:1095
virtual int get_int() const
Definition: character.cpp:4081
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4435
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4179
int int_cur
Definition: character.h:265
int get_rad() const
Definition: character.cpp:7046
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9063
virtual int get_per() const
Definition: character.cpp:4077
void mod_stamina(int mod)
Definition: character.cpp:7085
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8633
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1506
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4194
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1372
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:4837
bool is_tool() const
Definition: item.cpp:6953
int charges
Definition: item.h:2196
bool is_armor() const
Definition: item.cpp:6704
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5501
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5421
void remove_trap(const tripoint &p)
Definition: map.cpp:5366
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1615 of file game.cpp.

1616{
1617 if( u.has_effect( effect_sleep ) ) {
1618 // Can't interrupt
1619 return;
1620 }
1621
1622 bool has_activity = u.activity && u.activity.moves_left > 0;
1623 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1624
1625 if( !has_activity && !is_travelling ) {
1626 // Nohing to interrupt
1627 return;
1628 }
1629
1630 // Key poll may be quite expensive, so limit it to 10 times per second.
1631 static auto last_poll = std::chrono::steady_clock::now();
1632 auto now = std::chrono::steady_clock::now();
1633 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1634 ( now - last_poll ).count();
1635
1636 if( difference > 100 ) {
1638 last_poll = now;
1639 }
1640
1641 // If player is performing a task and a monster is dangerously close, warn them
1642 // regardless of previous safemode warnings.
1643 // Distraction Manager can change this.
1644 if( ( has_activity || is_travelling ) && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1646 Creature *hostile_critter = is_hostile_very_close();
1647 if( hostile_critter != nullptr ) {
1649 string_format( _( "The %s is dangerously close!" ),
1650 hostile_critter->get_name() ) );
1651 }
1652 }
1653}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9194
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:1976
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 8691 of file game.cpp.

8692{
8693 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8694
8695 if( !harmful_stuff.empty() &&
8696 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
8697 return false;
8698 }
8699 if( !harmful_stuff.empty() && u.is_mounted() &&
8700 m.tr_at( dest_loc ).loadid == tr_ledge ) {
8701 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
8702 u.mounted_creature->get_name() );
8703 return false;
8704 }
8705 return true;
8706}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11280 of file game.cpp.

11281{
11282 const WORLDPTR active_world = world_generator->active_world;
11283 if( active_world == nullptr ) {
11284 return;
11285 }
11286
11287 if( active_world->save_exists( save_t::from_save_id( u.get_save_id() ) ) ) {
11288 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11289 MAPBUFFER.clear();
11291 try {
11292 setup();
11293 } catch( const std::exception &err ) {
11294 debugmsg( "Error: %s", err.what() );
11295 }
11297 }
11298 } else {
11299 popup_getkey( _( "No saves for current character yet." ) );
11300 }
11301}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2519
void setup()
Definition: game.cpp:475
static save_t from_save_id(const std::string &save_id)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:457
bool save_exists(const save_t &name) const

References _, mapbuffer::clear(), overmapbuffer::clear(), debugmsg, save_t::from_save_id(), avatar::get_save_id(), load(), MAPBUFFER, moves_since_last_save, overmap_buffer, popup_getkey(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11258 of file game.cpp.

11259{
11260 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11261 if( !moves_since_last_save ) {
11262 return;
11263 }
11264 add_msg( m_info, _( "Saving game, this may take a while" ) );
11265
11267 popup.message( "%s", _( "Saving game, this may take a while" ) );
11270
11271 time_t now = time( nullptr ); //timestamp for start of saving procedure
11272
11273 //perform save
11274 save();
11275 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11277 last_save_timestamp = now;
11278}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), save(), and time.

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 463 of file game.cpp.

464{
465 if( was_fullscreen ) {
466 if( !fullscreen ) {
468 }
469 }
470}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 873 of file game.cpp.

874{
875 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
876 // and not invoke "on_load" for those NPCs that avoided unloading this way.
877 unload_npcs();
878 load_npcs();
879}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( std::function< void(std::string)>  out)

Definition at line 427 of file game.cpp.

428{
429#if defined(TILES)
430 // Disable UIs below to avoid accessing the tile context during loading.
432 try {
433 tilecontext->reinit();
434 std::vector<mod_id> dummy;
435 tilecontext->load_tileset(
436 get_option<std::string>( "TILES" ),
437 world_generator->active_world ? world_generator->active_world->active_mod_order : dummy,
438 /*precheck=*/false,
439 /*force=*/true,
440 /*pump_events=*/true
441 );
442 tilecontext->do_tile_loading_report( out );
443 } catch( const std::exception &err ) {
444 popup( _( "Loading the tileset failed: %s" ), err.what() );
445 }
446 g->reset_zoom();
447 g->mark_main_ui_adaptor_resize();
448#endif // TILES
449}

References _, g, popup(), and world_generator.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2253 of file game.cpp.

2254{
2256 return remoteveh_cache;
2257 }
2259 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2260 if( remote_veh_string.str().empty() ||
2262 remoteveh_cache = nullptr;
2263 } else {
2264 tripoint vp;
2265 remote_veh_string >> vp.x >> vp.y >> vp.z;
2266 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2267 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2268 remoteveh_cache = veh;
2269 } else {
2270 remoteveh_cache = nullptr;
2271 }
2272 }
2273 return remoteveh_cache;
2274}
vehicle * remoteveh_cache
Definition: game.h:1044
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3360
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1885 of file game.cpp.

1886{
1887 follower_ids.erase( id );
1888 u.follower_ids.erase( id );
1889}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 4717 of file game.cpp.

4718{
4719 critter_tracker->remove( critter );
4720}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 10779 of file game.cpp.

10780{
10781 for( auto &elem : coming_to_stairs ) {
10782 elem.staircount = 0;
10783 const tripoint pnt( elem.pos().xy(), get_levz() );
10784 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
10785 }
10786
10787 coming_to_stairs.clear();
10788}
std::vector< monster > coming_to_stairs
Definition: game.h:982

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7151 of file game.cpp.

7153{
7154 const int width = getmaxx( window );
7155 for( int i = 1; i < TERMX; i++ ) {
7156 if( i < width ) {
7157 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7158 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7159 LINE_OXOX ); // -
7160 }
7161
7162 if( i < TERMY - height ) {
7163 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7164 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7165 }
7166 }
7167
7168 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7169 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7170
7171 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7172 LINE_XXXO ); // |-
7173 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7174 LINE_XOXX ); // -|
7175
7176 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7177 wprintz( window, c_white, _( "Items" ) );
7178
7179 std::string sSort;
7180 if( bRadiusSort ) {
7181 //~ Sort type: distance.
7182 sSort = _( "<s>ort: dist" );
7183 } else {
7184 //~ Sort type: category.
7185 sSort = _( "<s>ort: cat" );
7186 }
7187
7188 int letters = utf8_width( sSort );
7189
7190 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7191
7192 std::vector<std::string> tokens;
7193 if( !sFilter.empty() ) {
7194 tokens.emplace_back( _( "<R>eset" ) );
7195 }
7196
7197 tokens.emplace_back( _( "<E>xamine" ) );
7198 tokens.emplace_back( _( "<C>ompare" ) );
7199 tokens.emplace_back( _( "<F>ilter" ) );
7200 tokens.emplace_back( _( "<+/->Priority" ) );
7201
7202 int gaps = tokens.size() + 1;
7203 letters = 0;
7204 int n = tokens.size();
7205 for( int i = 0; i < n; i++ ) {
7206 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7207 }
7208
7209 int usedwidth = letters;
7210 const int gap_spaces = ( width - usedwidth ) / gaps;
7211 usedwidth += gap_spaces * gaps;
7212 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7213
7214 for( int i = 0; i < n; i++ ) {
7215 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7216 tokens[i] ) + gap_spaces;
7217 }
7218}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3556 of file game.cpp.

3557{
3558 for( float &lev : latest_lightlevels ) {
3559 lev = -std::numeric_limits<float>::max();
3560 }
3561}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 2631 of file game.cpp.

2632{
2633 for( auto elem : follower_ids ) {
2634 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
2635 if( !npc_to_get ) {
2636 continue;
2637 }
2638 npc *npc_to_add = npc_to_get.get();
2639 npc_to_add->chatbin.missions.clear();
2640 npc_to_add->chatbin.missions_assigned.clear();
2641 npc_to_add->mission = NPC_MISSION_NULL;
2642 npc_to_add->chatbin.mission_selected = nullptr;
2643 npc_to_add->set_attitude( NPCATT_NULL );
2644 npc_to_add->op_of_u.anger = 0;
2645 npc_to_add->op_of_u.fear = 0;
2646 npc_to_add->op_of_u.trust = 0;
2647 npc_to_add->op_of_u.value = 0;
2648 npc_to_add->op_of_u.owed = 0;
2649 npc_to_add->set_fac( faction_id( "no_faction" ) );
2651 npc_to_add->global_omt_location(),
2652 npc_to_add->getID() ) );
2653
2654 }
2655
2656}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3169
npc_chatbin chatbin
Definition: npc.h:1290
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2660
npc_opinion op_of_u
Definition: npc.h:1289
void set_fac(const faction_id &id)
Definition: npc.cpp:473
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:715
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:720
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:711
int value
Definition: npc.h:205
int trust
Definition: npc.h:203
int owed
Definition: npc.h:207
int fear
Definition: npc.h:204
int anger
Definition: npc.h:206

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7066 of file game.cpp.

7067{
7068#if defined(TILES)
7070 rescale_tileset( tileset_zoom );
7071#endif // TILES
7072}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 4847 of file game.cpp.

4848{
4849 if( !it.is_corpse() ) {
4850 debugmsg( "Tried to revive a non-corpse." );
4851 return false;
4852 }
4853 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
4854 ( it.get_mtype()->id );
4855 monster &critter = *newmon_ptr;
4856 critter.init_from_item( it );
4857 if( critter.get_hp() < 1 ) {
4858 // Failed reanimation due to corpse being too burned
4859 return false;
4860 }
4861 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
4862 it.has_flag( "QUARTERED" ) ) {
4863 // Failed reanimation due to corpse being butchered
4864 return false;
4865 }
4866
4867 critter.no_extra_death_drops = true;
4868 critter.add_effect( effect_downed, 5_turns, num_bp );
4869 for( const item &component : it.components ) {
4870 critter.corpse_components.push_back( component );
4871 }
4872
4873 if( it.get_var( "zlave" ) == "zlave" ) {
4874 critter.add_effect( effect_pacified, 1_turns, num_bp );
4875 critter.add_effect( effect_pet, 1_turns, num_bp );
4876 }
4877
4878 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
4879 for( auto &ammo : critter.ammo ) {
4880 ammo.second = 0;
4881 }
4882 }
4883
4884 return place_critter_at( newmon_ptr, p );
4885}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4645
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1030
const mtype * get_mtype() const
Definition: item.cpp:6625
std::list< item > components
Definition: item.h:2159
bool has_flag(const std::string &flag) const
Definition: item.cpp:5303
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6620
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2915
bool no_extra_death_drops
Definition: monster.h:479
std::vector< item > corpse_components
Definition: monster.h:456
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2785
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 2732 of file game.cpp.

2733{
2734 try {
2735 if( !save_player_data() ||
2737 !save_artifacts() ||
2738 !save_maps() ||
2739 !get_auto_pickup().save_character() ||
2741 !get_safemode().save_character() ||
2742 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
2743 JsonOut jsout( fout );
2744 uistate.serialize( jsout );
2745 }, _( "uistate data" ) ) ) {
2746 return false;
2747 } else {
2748 world_generator->active_world->add_save( save_t::from_save_id( u.get_save_id() ) );
2749 return true;
2750 }
2751 } catch( std::ios::failure &err ) {
2752 popup( _( "Failed to save game data" ) );
2753 return false;
2754 }
2755}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:575
bool save_player_data()
Definition: game.cpp:2686
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_save_id(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), avatar::get_save_id(), get_world_base_save_path(), popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 2667 of file game.cpp.

2668{
2669 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
2670 return ::save_artifacts( artfilename );
2671}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 4908 of file game.cpp.

4909{
4910 int assist_bonus = installer.get_effect_int( effect_assisted );
4911
4912 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
4915 -1 );
4916
4917 int damage = cyborg->damage();
4918 int dmg_lvl = cyborg->damage_level( 4 );
4919 int difficulty = 12;
4920
4921 if( damage != 0 ) {
4922
4923 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
4924 dmg_lvl );
4925
4926 // Damage of the cyborg increases difficulty
4927 difficulty += dmg_lvl;
4928 }
4929
4930 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
4931 int success = chance_of_success - rng( 1, 100 );
4932
4933 if( !g->u.query_yn(
4934 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
4935 100 - static_cast<int>( chance_of_success ) ) ) {
4936 return;
4937 }
4938
4939 if( success > 0 ) {
4940 add_msg( m_good, _( "Successfully removed Personality override." ) );
4941 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
4942
4943 delete_cyborg_item( g->m, couch_pos, cyborg );
4944
4945 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
4946 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4947 tmp->load_npc_template( npc_cyborg );
4948 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
4950 tmp->hurtall( dmg_lvl * 10, nullptr );
4951 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
4952 load_npcs();
4953
4954 } else {
4955 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
4956 adjusted_skill ) );
4957 const int fail_type = std::min( 5, failure_level );
4958 switch( fail_type ) {
4959 case 1:
4960 case 2:
4961 add_msg( m_info, _( "The removal fails." ) );
4962 add_msg( m_bad, _( "The body is damaged." ) );
4963 cyborg->set_damage( damage + 1000 );
4964 break;
4965 case 3:
4966 case 4:
4967 add_msg( m_info, _( "The removal fails badly." ) );
4968 add_msg( m_bad, _( "The body is badly damaged!" ) );
4969 cyborg->set_damage( damage + 2000 );
4970 break;
4971 case 5:
4972 add_msg( m_info, _( "The removal is a catastrophe." ) );
4973 add_msg( m_bad, _( "The body is destroyed!" ) );
4974 delete_cyborg_item( g->m, couch_pos, cyborg );
4975 break;
4976 default:
4977 break;
4978 }
4979
4980 }
4981
4982}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1997
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1954
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:714
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:701
int damage() const
How much damage has the item sustained?
Definition: item.cpp:696
static const skill_id skill_computer("computer")
static void delete_cyborg_item(map &m, const tripoint &couch_pos, item *cyborg)
Definition: game.cpp:4887
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), delete_cyborg_item(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), overmapbuffer::insert_npc(), load_npcs(), m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 2659 of file game.cpp.

2660{
2661 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
2662 return write_to_file( masterfile, [&]( std::ostream & fout ) {
2663 serialize_master( fout );
2664 }, _( "factions data" ) );
2665}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1243

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 2673 of file game.cpp.

2674{
2675 try {
2676 m.save();
2677 overmap_buffer.save(); // can throw
2678 MAPBUFFER.save(); // can throw
2679 return true;
2680 } catch( const std::exception &err ) {
2681 popup( _( "Failed to save the maps: %s" ), err.what() );
2682 return false;
2683 }
2684}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:98

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 2686 of file game.cpp.

2687{
2688 const std::string playerfile = get_player_base_save_path();
2689
2690 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
2691 serialize( fout );
2692 }, _( "player data" ) );
2693 const bool saved_map_memory = u.save_map_memory();
2694 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
2695 std::ostream & fout ) {
2696 fout << memorial().dump();
2697 }, _( "player memorial" ) );
2698#if defined(__ANDROID__)
2699 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
2700 std::ostream & fout ) {
2701 save_shortcuts( fout );
2702 }, _( "quick shortcuts" ) );
2703#endif
2704 const bool saved_diary = u.get_avatar_diary()->store();
2705 return saved_data && saved_map_memory && saved_log && saved_diary
2706#if defined(__ANDROID__)
2707 && saved_shortcuts
2708#endif
2709 ;
2710}
bool save_map_memory()
Definition: avatar.cpp:132
bool store()
Definition: diary.cpp:760
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:11997
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), avatar::get_avatar_diary(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), diary::store(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:974
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1243 of file savegame.cpp.

1244{
1245 fout << "# version " << savegame_version << std::endl;
1246 try {
1247 JsonOut json( fout, true ); // pretty-print
1248 json.start_object();
1249
1250 json.member( "next_mission_id", next_mission_id );
1251 json.member( "next_npc_id", next_npc_id );
1252
1253 json.member( "active_missions" );
1254 mission::serialize_all( json );
1255
1256 json.member( "factions", *faction_manager_ptr );
1257 json.member( "seed", seed );
1258
1259 json.member( "weather" );
1260 json.start_object();
1261 json.member( "lightning", get_weather().lightning_active );
1262 json.end_object();
1263
1264 json.end_object();
1265 } catch( const JsonError &e ) {
1266 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1267 }
1268}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1234

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1793 of file game.cpp.

1794{
1795 critter_died = true;
1796}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( point  p)

Definition at line 1603 of file game.cpp.

1604{
1605 // remove the previous driving offset,
1606 // store the new offset and apply the new offset.
1613}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1788 of file game.cpp.

1789{
1790 npcs_dirty = true;
1791}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 8618 of file game.cpp.

8619{
8620 safe_mode = mode;
8622}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7074 of file game.cpp.

7075{
7076#if defined(TILES)
7077 if( tileset_zoom != level ) {
7078 tileset_zoom = level;
7079 rescale_tileset( tileset_zoom );
7080 }
7081#else
7082 static_cast<void>( level );
7083#endif // TILES
7084}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2276 of file game.cpp.

2277{
2279 remoteveh_cache = veh;
2280 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2282 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2283 veh = nullptr;
2284 }
2285
2286 if( veh == nullptr ) {
2287 u.remove_value( "remote_controlling_vehicle" );
2288 return;
2289 }
2290
2291 std::stringstream remote_veh_string;
2292 const tripoint vehpos = veh->global_pos3();
2293 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2294 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2295}
void remove_value(const std::string &key)
Definition: creature.cpp:1356

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 475 of file game.cpp.

476{
477 loading_ui ui( true );
478
480
481 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
482 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
483 }
484
485 m = map( get_option<bool>( "ZLEVELS" ) );
486
488 next_mission_id = 1;
489 new_game = true;
490 uquit = QUIT_NO; // We haven't quit the game
491 bVMonsterLookFire = true;
492
493 // invalidate calendar caches in case we were previously playing
494 // a different world
495 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
496 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
497
500
501 turnssincelastmon = 0; //Auto safe mode init
502
505 coming_to_stairs.clear();
506 active_npc.clear();
507 faction_manager_ptr->clear();
512
513 SCT.vSCT.clear(); //Delete pending messages
514
515 stats().clear();
516 // reset kill counts
517 kill_tracker_ptr->clear();
519 // reset follower list
520 follower_ids.clear();
521 scent.reset();
522
524 remoteveh_cache = nullptr;
525
526 token_provider_ptr->clear();
527 // back to menu for save loading, new game etc
528}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:4722
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void load_world_modfiles(loading_ui &ui, const std::string &artifacts_file)
Load & finalize modlist needed for the current world.
Definition: init.cpp:874
void reset_sounds()
Definition: sounds.cpp:565

References achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, get_world_base_save_path(), kill_tracker_ptr, init::load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), QUIT_NO, remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), SAVE_ARTIFACTS(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4575 of file game.cpp.

4576{
4577 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4578 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4579 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4580 }
4581 if( critter.is_monster() ) {
4582 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4583 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4584 return std::dynamic_pointer_cast<T>( mon_ptr );
4585 }
4586 }
4587 }
4588 if( critter.is_npc() ) {
4589 for( auto &cur_npc : active_npc ) {
4590 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4591 return std::dynamic_pointer_cast<T>( cur_npc );
4592 }
4593 }
4594 }
4595 return nullptr;
4596}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( point  delta)

Definition at line 12010 of file game.cpp.

12011{
12012 for( tripoint &p : destination_preview ) {
12013 p += delta;
12014 }
12015}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11014 of file game.cpp.

11015{
11016 // If either shift argument is non-zero, we're shifting.
11017 if( shift == tripoint_zero ) {
11018 return;
11019 }
11020 for( monster &critter : all_monsters() ) {
11021 if( shift.xy() != point_zero ) {
11022 critter.shift( shift.xy() );
11023 }
11024
11025 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11026 // We're inbounds, so don't despawn after all.
11027 // No need to shift Z-coordinates, they are absolute
11028 continue;
11029 }
11030 // Either a vertical shift or the critter is now outside of the reality bubble,
11031 // anyway: it must be saved and removed.
11032 despawn_monster( critter );
11033 }
11034 // The order in which zombies are shifted may cause zombies to briefly exist on
11035 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11036 critter_tracker->rebuild_cache();
11037}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12017 of file game.cpp.

12018{
12019 ///\EFFECT_DEX decreases chances of slipping while climbing
12020 int climb = u.dex_cur;
12021 if( u.has_trait( trait_BADKNEES ) ) {
12022 climb = climb / 2;
12023 }
12024 if( one_in( climb ) ) {
12025 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12026 if( climb <= 1 ) {
12027 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12028 }
12029 return true;
12030 }
12031 return false;
12032}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 4733 of file game.cpp.

4734{
4735 if( one_in( 100 ) ) {
4736 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
4737 tmp->randomize( NC_HALLU );
4738 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
4739 if( !critter_at( p, true ) ) {
4741 load_npcs();
4742 return true;
4743 } else {
4744 return false;
4745 }
4746 }
4747
4749 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
4750 phantasm->hallucination = true;
4751 phantasm->spawn( p );
4752
4753 //Don't attempt to place phantasms inside of other creatures
4754 if( !critter_at( phantasm->pos(), true ) ) {
4755 return critter_tracker->add( phantasm );
4756 } else {
4757 return false;
4758 }
4759}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 2727 of file game.cpp.

2728{
2729 return *spell_events_ptr;
2730}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 11577 of file game.cpp.

11578{
11579 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
11580 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
11581 scen->has_flag( "SUM_ADV_START" );
11582
11584 if( scen_season ) {
11585 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
11587 get_option<int>( "INITIAL_TIME" );
11588 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
11589 if( scen->has_flag( "SPR_START" ) ) {
11591 } else if( scen->has_flag( "SUM_START" ) ) {
11594 } else if( scen->has_flag( "AUT_START" ) ) {
11597 } else if( scen->has_flag( "WIN_START" ) ) {
11600 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
11603 } else {
11604 debugmsg( "The Unicorn" );
11605 }
11606 } else {
11607 // No scenario, so use the starting date+time configured in world options
11608 int initial_days = get_option<int>( "INITIAL_DAY" );
11609 if( initial_days == -1 ) {
11610 // 0 - 363 for a 91 day season
11611 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
11612 }
11614
11615 // Determine the season based off how long the seasons are set to be
11616 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
11617 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
11618 if( season_number == 0 ) {
11620 } else if( season_number == 1 ) {
11622 } else if( season_number == 2 ) {
11624 } else {
11626 }
11627
11629 + 1_hours * get_option<int>( "INITIAL_TIME" )
11630 + 1_days * get_option<int>( "SPAWN_DELAY" );
11631 }
11632
11634}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:981
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 554 of file game.cpp.

555{
556 if( !gamemode ) {
557 gamemode = std::make_unique<special_game>();
558 }
559
560 seed = rng_bits();
561 new_game = true;
564 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
565 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
568
570
573 popup.message( "%s", _( "Please wait as we build your world" ) );
576
577 load_master();
578 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
579
583 do {
584 omtstart = start_loc.find_player_initial_location();
585 if( omtstart == overmap::invalid_tripoint ) {
586 if( query_yn(
587 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
590 } else {
591 return false;
592 }
593 }
594 } while( omtstart == overmap::invalid_tripoint );
595
596 start_loc.prepare_map( omtstart );
597
598 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
599 if( u.starting_vehicle &&
600 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
601 std::vector<std::string> {} ) ) {
602 debugmsg( "could not place starting vehicle" );
603 }
604
605 if( scen->has_map_extra() ) {
606 // Map extras can add monster spawn points and similar and should be done before the main
607 // map is loaded.
608 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
609 }
610
611 // TODO: fix point types
612 tripoint lev = project_to<coords::sm>( omtstart ).raw();
613 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
614 lev.x -= HALF_MAPSIZE;
615 lev.y -= HALF_MAPSIZE;
616 load_map( lev, /*pump_events=*/true );
617
620 // Do this after the map cache has been built!
621 start_loc.place_player( u );
622 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
625 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
627 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
628
629 u.moves = 0;
630 u.process_turn(); // process_turn adds the initial move points
634 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
636
637 //Reset character safe mode/pickup rules
642
643 //Put some NPCs in there!
644 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
645 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
646 !g->scen->has_flag( "LONE_START" ) ) ) {
648 }
649 //Load NPCs. Set nearby npcs to active.
650 load_npcs();
651 // Spawn the monsters
652 const bool spawn_near =
653 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
654 // Surrounded start ones
655 if( spawn_near ) {
656 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
657 }
658
659 m.spawn_monsters( !spawn_near ); // Static monsters
660
661 // Make sure that no monsters are near the player
662 // This can happen in lab starts
663 if( !spawn_near ) {
664 for( monster &critter : all_monsters() ) {
665 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
666 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
667 remove_zombie( critter );
668 }
669 }
670 }
671
672 //Create mutation_category_level
674 //Calculate mutation drench protection stats
677 if( scen->has_flag( "FIRE_START" ) ) {
678 start_loc.burn( omtstart, 3, 3 );
679 }
680 if( scen->has_flag( "INFECTED" ) ) {
682 }
683 if( scen->has_flag( "BAD_DAY" ) ) {
684 u.add_effect( effect_flu, 1000_minutes );
685 u.add_effect( effect_drunk, 270_minutes );
686 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
687 }
688 if( scen->has_flag( "HELI_CRASH" ) ) {
689 start_loc.handle_heli_crash( u );
690 bool success = false;
691 for( auto v : m.get_vehicles() ) {
692 std::string name = v.v->type.str();
693 std::string search = std::string( "helicopter" );
694 if( name.find( search ) != std::string::npos ) {
695 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
696 const tripoint pos = vp.pos();
697 u.setpos( pos );
698
699 // Delete the items that would have spawned here from a "corpse"
700 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
701 vehicle_stack here = v.v->get_items( sp );
702
703 for( auto iter = here.begin(); iter != here.end(); ) {
704 iter = here.erase( iter );
705 }
706 }
707
708 auto mons = critter_tracker->find( pos );
709 if( mons != nullptr ) {
710 critter_tracker->remove( *mons );
711 }
712
713 success = true;
714 break;
715 }
716 if( success ) {
717 v.v->name = "Bird Wreckage";
718 break;
719 }
720 }
721 }
722 }
723 if( scen->has_flag( "BORDERED" ) ) {
724 overmap &starting_om = get_cur_om();
725 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
726 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
728 }
729
730 }
731 for( auto &e : u.inv_dump() ) {
732 e->set_owner( g->u );
733 }
734 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
735 update_map( u );
736 // Profession pets
737 for( const mtype_id &elem : u.starting_pets ) {
738 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
739 mon->friendly = -1;
740 mon->add_effect( effect_pet, 1_turns, num_bp );
741 } else {
742 add_msg( m_debug, "cannot place starting pet, no space!" );
743 }
744 }
745 // Assign all of this scenario's missions to the player.
746 for( const mission_type_id &m : scen->missions() ) {
747 const auto mission = mission::reserve_new( m, character_id() );
748 mission->assign( u );
749 }
750 g->events().send<event_type::game_start>( u.getID() );
751 for( Skill &elem : Skill::skills ) {
752 int level = u.get_skill_level_object( elem.ident() ).level();
753 if( level > 0 ) {
754 g->events().send<event_type::gains_skill_level>( u.getID(), elem.ident(), level );
755 }
756 }
757 return true;
758}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:366
bool last_climate_control_ret
Definition: character.h:2270
SkillLevel & get_skill_level_object(const skill_id &ident)
Definition: character.cpp:3326
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7789
void set_stamina(int new_stamina)
Definition: character.cpp:7080
time_point next_climate_control_check
Definition: character.h:2269
int get_stamina_max() const
Definition: character.cpp:7069
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7766
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:11577
void create_starting_npcs()
Definition: game.cpp:886
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:11877
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:760
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6500
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2164
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:238
vproto_id starting_vehicle
Definition: player.h:250
std::vector< mtype_id > starting_pets
Definition: player.h:251
start_location_id start_location
Definition: player.h:239
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:60
iterator erase(const_iterator it) override
Definition: vehicle.cpp:231
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:137
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:108
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), mapbuffer::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, gains_skill_level, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_distraction_manager(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_skill_level_object(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, distraction_manager::distraction_manager_gui::load(), safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), Character::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), Skill::skills, map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10377 of file game.cpp.

10378{
10379 // Find target items and quantities thereof for the new activity
10380 std::vector<item_location> target_items;
10381 std::vector<int> quantities;
10382
10383 map_stack items = m.i_at( pos );
10384 for( item &it : items ) {
10385 // Liquid cannot be picked up
10386 if( it.made_of( LIQUID ) ) {
10387 continue;
10388 }
10389 target_items.emplace_back( map_cursor( pos ), &it );
10390 // Quantity of 0 means move all
10391 quantities.push_back( 0 );
10392 }
10393
10394 if( target_items.empty() ) {
10395 // Nothing to haul
10396 return;
10397 }
10398
10399 // Whether the destination is inside a vehicle (not supported)
10400 const bool to_vehicle = false;
10401 // Destination relative to the player
10402 const tripoint relative_destination{};
10403
10405 target_items,
10406 quantities,
10407 to_vehicle,
10408 relative_destination
10409 ) ) );
10410}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 2717 of file game.cpp.

2718{
2719 return *stats_tracker_ptr;
2720}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 4761 of file game.cpp.

4762{
4763 if( &a == &b ) {
4764 // No need to do anything, but print a debugmsg anyway
4765 debugmsg( "Tried to swap %s with itself", a.disp_name() );
4766 return true;
4767 }
4768 if( critter_at( a.pos() ) != &a ) {
4769 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4770 b.disp_name(), critter_at( a.pos() )->disp_name() );
4771 return false;
4772 }
4773 if( critter_at( b.pos() ) != &b ) {
4774 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
4775 a.disp_name(), critter_at( b.pos() )->disp_name() );
4776 return false;
4777 }
4778 // Simplify by "sorting" the arguments
4779 // Only the first argument can be u
4780 // If swapping player/npc with a monster, monster is second
4781 bool a_first = a.is_player() ||
4782 ( a.is_npc() && !b.is_player() );
4783 Creature &first = a_first ? a : b;
4784 Creature &second = a_first ? b : a;
4785 // Possible options:
4786 // both first and second are monsters
4787 // second is a monster, first is a player or an npc
4788 // first is a player, second is an npc
4789 // both first and second are npcs
4790 if( first.is_monster() ) {
4791 monster *m1 = dynamic_cast< monster * >( &first );
4792 monster *m2 = dynamic_cast< monster * >( &second );
4793 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
4794 debugmsg( "Couldn't swap two monsters" );
4795 return false;
4796 }
4797
4798 critter_tracker->swap_positions( *m1, *m2 );
4799 return true;
4800 }
4801
4802 player *u_or_npc = dynamic_cast< player * >( &first );
4803 player *other_npc = dynamic_cast< player * >( &second );
4804
4805 if( u_or_npc->in_vehicle ) {
4806 m.unboard_vehicle( u_or_npc->pos() );
4807 }
4808
4809 if( other_npc && other_npc->in_vehicle ) {
4810 m.unboard_vehicle( other_npc->pos() );
4811 }
4812
4813 tripoint temp = second.pos();
4814 second.setpos( first.pos() );
4815
4816 if( first.is_player() ) {
4817 walk_move( temp );
4818 } else {
4819 first.setpos( temp );
4820 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4821 m.board_vehicle( u_or_npc->pos(), u_or_npc );
4822 }
4823 }
4824
4825 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
4826 m.board_vehicle( other_npc->pos(), other_npc );
4827 }
4828 return true;
4829}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:8757
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7143 of file game.cpp.

7144{
7145 popup( _( "This binary was not compiled with tiles support." ) );
7146 return false;
7147}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7137 of file game.cpp.

7138{
7139 popup( _( "This binary was not compiled with tiles support." ) );
7140 return false;
7141}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 453 of file game.cpp.

454{
455 if( fullscreen ) {
456 was_fullscreen = true;
458 } else {
459 was_fullscreen = false;
460 }
461}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11184 of file game.cpp.

11185{
11187}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 406 of file game.cpp.

407{
408#if !defined(TILES)
411#else
412 toggle_fullscreen_window();
413#endif
414}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_gate()

void game::toggle_gate ( const tripoint p)

Definition at line 5130 of file game.cpp.

5131{
5132 gates::toggle_gate( p, u );
5133}
void toggle_gate(const tripoint &pos, player &p)
opens/closes the gate via player's activity
Definition: gates.cpp:236

References gates::toggle_gate(), and u.

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 416 of file game.cpp.

417{
418#if defined(TILES)
420 clear_window_area( w_pixel_minimap );
421 }
424#endif // TILES
425}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2297 of file game.cpp.

2298{
2299 bool new_destination = true;
2300 if( !destination_preview.empty() ) {
2301 auto &final_destination = destination_preview.back();
2302 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2303 // Second click
2304 new_destination = false;
2306 destination_preview.clear();
2308 if( act == ACTION_NULL ) {
2309 // Something went wrong
2311 return false;
2312 }
2313 }
2314 }
2315
2316 if( new_destination ) {
2318 u.get_path_avoid() );
2319 return false;
2320 }
2321
2322 return true;
2323}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2325 of file game.cpp.

2326{
2327 const bool cleared_destination = !destination_preview.empty();
2329 destination_preview.clear();
2330
2331 if( cleared_destination ) {
2332 // Produce no-op if auto-move had just been cleared on this action
2333 // e.g. from a previous single left mouse click. This has the effect
2334 // of right-click canceling an auto-move before it is initiated.
2335 return false;
2336 }
2337
2338 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2339 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2340 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2341 if( !u.sees( *mon ) ) {
2342 add_msg( _( "Nothing relevant here." ) );
2343 return false;
2344 }
2345
2346 if( !u.weapon.is_gun() ) {
2347 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2348 return false;
2349 }
2350
2351 // TODO: Add weapon range check. This requires weapon to be reloaded.
2352
2353 act = ACTION_FIRE;
2354 } else if( is_adjacent &&
2355 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2356 true ) ) {
2357 act = ACTION_CLOSE;
2358 } else if( is_self ) {
2360 } else if( is_adjacent ) {
2362 } else {
2363 add_msg( _( "Nothing relevant here." ) );
2364 return false;
2365 }
2366
2367 return true;
2368}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:4066
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 864 of file game.cpp.

865{
866 for( const auto &npc : active_npc ) {
867 npc->on_unload();
868 }
869
870 active_npc.clear();
871}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2665

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map(
207 tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ),
208 /*pump_events=*/true
209 );
210
211 safe_mode = static_cast<safe_mode_type>( tmprun );
212 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
214 }
215
216 std::string linebuff;
217 std::string linebuf;
218 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
219 scent.deserialize( linebuf );
220 scent.deserialize( linebuff, true );
221 } else {
222 scent.reset();
223 }
224 data.read( "active_monsters", *critter_tracker );
225
226 coming_to_stairs.clear();
227 for( auto elem : data.get_array( "stair_monsters" ) ) {
228 monster stairtmp;
229 elem.read( stairtmp );
230 coming_to_stairs.push_back( stairtmp );
231 }
232
233 if( data.has_object( "kill_tracker" ) ) {
234 data.read( "kill_tracker", *kill_tracker_ptr );
235 } else {
236 // Legacy support for when kills were stored directly in game
237 std::map<mtype_id, int> kills;
238 std::vector<std::string> npc_kills;
239 for( const JsonMember member : data.get_object( "kills" ) ) {
240 kills[mtype_id( member.name() )] = member.get_int();
241 }
242
243 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
244 npc_kills.push_back( npc_name );
245 }
246
247 kill_tracker_ptr->reset( kills, npc_kills );
248 }
249
250 data.read( "player", u );
252 data.read( "stats_tracker", *stats_tracker_ptr );
253 data.read( "achievements_tracker", *achievements_tracker_ptr );
254 data.read( "token_provider", token_provider_ptr );
256 Messages::deserialize( data );
257
258 } catch( const JsonError &jsonerr ) {
259 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
260 return;
261 }
262}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:429
bool has_object(const std::string &name) const
Definition: json.cpp:493
JsonArray get_array(const std::string &name) const
Definition: json.cpp:400
int get_int(const std::string &name) const
Definition: json.cpp:350
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:941
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:264
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:410
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), inp_mngr, kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, input_manager::pump_events(), JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1193 of file savegame.cpp.

1194{
1196 chkversion( fin );
1197 if( savegame_loading_version < 11 ) {
1198 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1199 popup->message(
1200 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1204 }
1205 try {
1206 // single-pass parsing example
1207 JsonIn jsin( fin );
1208 jsin.start_object();
1209 while( !jsin.end_object() ) {
1210 std::string name = jsin.get_member_name();
1211 if( name == "next_mission_id" ) {
1212 next_mission_id = jsin.get_int();
1213 } else if( name == "next_npc_id" ) {
1214 next_npc_id.deserialize( jsin );
1215 } else if( name == "active_missions" ) {
1217 } else if( name == "factions" ) {
1218 jsin.read( *faction_manager_ptr );
1219 } else if( name == "seed" ) {
1220 jsin.read( seed );
1221 } else if( name == "weather" ) {
1222 JsonObject w = jsin.get_object();
1223 w.read( "lightning", get_weather().lightning_active );
1224 } else {
1225 // silently ignore anything else
1226 jsin.skip_value();
1227 }
1228 }
1229 } catch( const JsonError &e ) {
1230 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1231 }
1232}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1183

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 10645 of file game.cpp.

10646{
10647 point shift;
10648
10649 while( x < HALF_MAPSIZE_X ) {
10650 x += SEEX;
10651 shift.x--;
10652 }
10653 while( x >= HALF_MAPSIZE_X + SEEX ) {
10654 x -= SEEX;
10655 shift.x++;
10656 }
10657 while( y < HALF_MAPSIZE_Y ) {
10658 y += SEEY;
10659 shift.y--;
10660 }
10661 while( y >= HALF_MAPSIZE_Y + SEEY ) {
10662 y -= SEEY;
10663 shift.y++;
10664 }
10665
10666 if( shift == point_zero ) {
10667 // adjust player position
10668 u.setpos( tripoint( x, y, get_levz() ) );
10669 // Update what parts of the world map we can see
10670 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
10671 // TODO: only make this call if we changed z-level
10673 // Not actually shifting the submaps, all the stuff below would do nothing
10674 return point_zero;
10675 }
10676
10677 // this handles loading/unloading submaps that have scrolled on or off the viewport
10678 // NOLINTNEXTLINE(cata-use-named-point-constants)
10679 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
10680 point remaining_shift = shift;
10681 while( remaining_shift != point_zero ) {
10682 point this_shift = clamp( remaining_shift, size_1 );
10683 m.shift( this_shift );
10684 remaining_shift -= this_shift;
10685 }
10686
10687 grid_tracker_ptr->load( m );
10688
10689 // Shift monsters
10690 shift_monsters( tripoint( shift, 0 ) );
10691 const point shift_ms = sm_to_ms_copy( shift );
10692 u.shift_destination( -shift_ms );
10693
10694 // Shift NPCs
10695 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
10696 ( *it )->shift( shift );
10697 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
10698 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
10699 //Remove the npc from the active list. It remains in the overmap list.
10700 ( *it )->on_unload();
10701 it = active_npc.erase( it );
10702 } else {
10703 it++;
10704 }
10705 }
10706
10707 scent.shift( shift_ms );
10708
10709 // Also ensure the player is on current z-level
10710 // get_levz() should later be removed, when there is no longer such a thing
10711 // as "current z-level"
10712 u.setpos( tripoint( x, y, get_levz() ) );
10713
10714 // Only do the loading after all coordinates have been shifted.
10715
10716 // Check for overmap saved npcs that should now come into view.
10717 // Put those in the active list.
10718 load_npcs();
10719
10720 // Make sure map cache is consistent since it may have shifted.
10721 if( m.has_zlevels() ) {
10722 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
10723 m.invalidate_map_cache( zlev );
10724 }
10725 } else {
10727 }
10729
10730 // Spawn monsters if appropriate
10731 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
10732 m.spawn_monsters( false ); // Static monsters
10733
10734 // Update what parts of the world map we can see
10736
10737 return shift;
10738}
void shift_destination(point shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11014
void shift(point s)
Shift the map along the vector s.
Definition: map.cpp:6872
void shift(point sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(point p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 10639 of file game.cpp.

10640{
10641 point p2( p.posx(), p.posy() );
10642 return update_map( p2.x, p2.y );
10643}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 10740 of file game.cpp.

10741{
10742 const tripoint_abs_omt ompos = u.global_omt_location();
10743 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
10744 const int dist_squared = dist * dist;
10745 // We can always see where we're standing
10746 overmap_buffer.set_seen( ompos, true );
10747 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
10748 const point_rel_omt delta = p.xy() - ompos.xy();
10749 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
10750 if( trigdist && h_squared > dist_squared ) {
10751 continue;
10752 }
10753 if( delta == point_rel_omt() ) {
10754 // 1. This case is already handled outside of the loop
10755 // 2. Calculating multiplier would cause division by zero
10756 continue;
10757 }
10758 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
10759 point abs_delta = delta.raw().abs();
10760 int max_delta = std::max( abs_delta.x, abs_delta.y );
10761 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
10762 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
10763 float sight_points = dist;
10764 for( auto it = line.begin();
10765 it != line.end() && sight_points >= 0; ++it ) {
10766 const oter_id &ter = overmap_buffer.ter( *it );
10767 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
10768 }
10769 if( sight_points >= 0 ) {
10770 tripoint_abs_omt seen( p );
10771 do {
10772 overmap_buffer.set_seen( seen, true );
10773 --seen.z();
10774 } while( seen.z() >= 0 );
10775 }
10776 }
10777}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:648
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 10792 of file game.cpp.

10793{
10794 // Search for the stairs closest to the player.
10795 std::vector<int> stairx;
10796 std::vector<int> stairy;
10797 std::vector<int> stairdist;
10798
10799 const bool from_below = monstairz < get_levz();
10800
10801 if( coming_to_stairs.empty() ) {
10802 return;
10803 }
10804
10805 if( m.has_zlevels() ) {
10806 debugmsg( "%d monsters coming to stairs on a map with z-levels",
10807 coming_to_stairs.size() );
10808 coming_to_stairs.clear();
10809 }
10810
10811 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
10812 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
10813 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
10814 stairx.push_back( dest.x );
10815 stairy.push_back( dest.y );
10816 stairdist.push_back( rl_dist( dest, u.pos() ) );
10817 }
10818 }
10819 if( stairdist.empty() ) {
10820 return; // Found no stairs?
10821 }
10822
10823 // Find closest stairs.
10824 size_t si = 0;
10825 for( size_t i = 0; i < stairdist.size(); i++ ) {
10826 if( stairdist[i] < stairdist[si] ) {
10827 si = i;
10828 }
10829 }
10830
10831 // Find up to 4 stairs for distance stairdist[si] +1
10832 std::vector<int> nearest;
10833 nearest.push_back( si );
10834 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
10835 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
10836 nearest.push_back( i );
10837 }
10838 }
10839 // Randomize the stair choice
10840 si = random_entry_ref( nearest );
10841
10842 // Attempt to spawn zombies.
10843 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
10844 point mpos( stairx[si], stairy[si] );
10845 monster &critter = coming_to_stairs[i];
10846 const tripoint dest {
10847 mpos, g->get_levz()
10848 };
10849
10850 // We might be not be visible.
10851 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
10852 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
10853 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
10854 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
10855 continue;
10856 }
10857
10858 critter.staircount -= 4;
10859 // Let the player know zombies are trying to come.
10860 if( u.sees( dest ) ) {
10861 std::string dump;
10862 if( critter.staircount > 4 ) {
10863 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
10864 } else {
10865 if( critter.staircount > 0 ) {
10866 dump += ( from_below ?
10867 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
10868 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
10869 critter.name(),
10870 m.tername( dest ) ) :
10871 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
10872 critter.name(),
10873 m.tername( dest ) ) );
10874 }
10875 }
10876
10877 add_msg( m_warning, dump );
10878 } else {
10880 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
10881 }
10882
10883 if( critter.staircount > 0 ) {
10884 continue;
10885 }
10886
10887 if( is_empty( dest ) ) {
10888 critter.spawn( dest );
10889 critter.staircount = 0;
10890 place_critter_at( make_shared_fast<monster>( critter ), dest );
10891 if( u.sees( dest ) ) {
10892 if( !from_below ) {
10893 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
10894 critter.name(),
10895 m.tername( dest ) );
10896 } else {
10897 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
10898 critter.name(),
10899 m.tername( dest ) );
10900 }
10901 }
10902 coming_to_stairs.erase( coming_to_stairs.begin() + i );
10903 continue;
10904 } else if( u.pos() == dest ) {
10905 // Monster attempts to push player of stairs
10907 int tries = 0;
10908
10909 // the critter is now right on top of you and will attack unless
10910 // it can find a square to push you into with one of his tries.
10911 const int creature_push_attempts = 9;
10912 const int player_throw_resist_chance = 3;
10913
10914 critter.spawn( dest );
10915 while( tries < creature_push_attempts ) {
10916 tries++;
10917 push.x = rng( -1, 1 );
10918 push.y = rng( -1, 1 );
10919 point ipos( mpos + push );
10920 tripoint pos( ipos, get_levz() );
10921 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
10922 critter.can_move_to( pos ) ) {
10923 bool resiststhrow = ( u.is_throw_immune() ) ||
10925 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
10926 u.moves -= 25; // small charge for avoiding the push altogether
10927 add_msg( _( "The %s fails to push you back!" ),
10928 critter.name() );
10929 return; //judo or leg brace prevent you from getting pushed at all
10930 }
10931 // Not accounting for tentacles latching on, so..
10932 // Something is about to happen, lets charge half a move
10933 u.moves -= 50;
10934 if( resiststhrow && ( u.is_throw_immune() ) ) {
10935 //we have a judoka who isn't getting pushed but counterattacking now.
10936 mattack::thrown_by_judo( &critter );
10937 return;
10938 }
10939 std::string msg;
10940 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
10941 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
10942 // dodge 12 - never get downed
10943 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
10944 u.add_effect( effect_downed, 2_turns );
10945 msg = _( "The %s pushed you back hard!" );
10946 } else {
10947 msg = _( "The %s pushed you back!" );
10948 }
10949 add_msg( m_warning, msg.c_str(), critter.name() );
10950 u.setx( u.posx() + push.x );
10951 u.sety( u.posy() + push.y );
10952 return;
10953 }
10954 }
10956 _( "The %s tried to push you back but failed! It attacks you!" ),
10957 critter.name() );
10958 critter.melee_attack( u );
10959 u.moves -= 50;
10960 return;
10961 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
10962 // Monster attempts to displace a monster from the stairs
10963 monster &other = *mon_ptr;
10964 critter.spawn( dest );
10965
10966 // the critter is now right on top of another and will push it
10967 // if it can find a square to push it into inside of his tries.
10968 const int creature_push_attempts = 9;
10969 const int creature_throw_resist = 4;
10970
10971 int tries = 0;
10972 point push2;
10973 while( tries < creature_push_attempts ) {
10974 tries++;
10975 push2.x = rng( -1, 1 );
10976 push2.y = rng( -1, 1 );
10977 point ipos2( mpos + push2 );
10978 tripoint pos( ipos2, get_levz() );
10979 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
10980 continue;
10981 }
10982 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
10983 other.setpos( tripoint( ipos2, get_levz() ) );
10984 other.moves -= 50;
10985 std::string msg;
10986 if( one_in( creature_throw_resist ) ) {
10987 other.add_effect( effect_downed, 2_turns );
10988 msg = _( "The %1$s pushed the %2$s hard." );
10989 } else {
10990 msg = _( "The %1$s pushed the %2$s." );
10991 }
10992 add_msg( m_neutral, msg, critter.name(), other.name() );
10993 return;
10994 }
10995 }
10996 return;
10997 }
10998 }
10999}
void setx(int x)
Definition: character.h:802
void sety(int y)
Definition: character.h:805
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:809
int monstairz
Definition: game.h:983
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8732
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:258
int posy() const override
Definition: monster.h:497
void melee_attack(Creature &target)
Definition: monster.cpp:1398
int staircount
Definition: monster.h:508
void spawn(const tripoint &p)
Definition: monster.cpp:482
int posx() const override
Definition: monster.h:494
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4674
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 4712 of file game.cpp.

4713{
4714 return critter_tracker->update_pos( critter, pos );
4715}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4495 of file game.cpp.

4496{
4497 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4498 add_msg( m_info, _( "You can not read a computer screen!" ) );
4499 return;
4500 }
4501 if( u.is_blind() ) {
4502 // we don't have screen readers in game
4503 add_msg( m_info, _( "You can not see a computer screen!" ) );
4504 return;
4505 }
4506 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4507 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4508 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4509 return;
4510 }
4511
4512 computer *used = m.computer_at( p );
4513
4514 if( used == nullptr ) {
4515 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4516 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4517 } else {
4518 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4519 }
4520 return;
4521 }
4522
4523 computer_session( *used ).use();
4524}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5647
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 1957 of file game.cpp.

1958{
1959 basecamp camp = m.hoist_submap_camp( u.pos() );
1960 if( camp.is_valid() ) {
1961 overmap_buffer.add_camp( camp );
1963 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
1964 std::string camp_name = _( "Faction Camp" );
1965 camp.set_name( camp_name );
1966 overmap_buffer.add_camp( camp );
1968 }
1969}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5678
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5673
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1899 of file game.cpp.

1900{
1901 for( auto &veh : m.get_vehicles() ) {
1902 vehicle *v = veh.v;
1905 if( other_v ) {
1906 // the other vehicle is towing us.
1907 v->tow_data.set_towing( other_v, v );
1909 }
1910 }
1911 }
1912}
tripoint other_towing_point
Definition: vehicle.h:168
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:6119
towing_data tow_data
Definition: vehicle.h:1969

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 1914 of file game.cpp.

1915{
1916 for( monster &m : all_monsters() ) {
1917 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
1918 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
1919 if( !mounted_pl ) {
1920 // Target no longer valid.
1921 m.mounted_player_id = character_id();
1922 m.remove_effect( effect_ridden );
1923 continue;
1924 }
1925 mounted_pl->mounted_creature = shared_from( m );
1926 mounted_pl->setpos( m.pos() );
1927 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
1928 m.mounted_player = mounted_pl;
1929 }
1930 }
1931}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 1933 of file game.cpp.

1934{
1935 // Make sure visible followers are in the list.
1936 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
1937 return guy.is_player_ally();
1938 } );
1939 for( npc *guy : visible_followers ) {
1940 update_faction_api( guy );
1941 add_npc_follower( guy->getID() );
1942 }
1943 // Make sure overmapbuffered NPC followers are in the list.
1944 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
1945 npc *guy = temp_guy.get();
1946 if( guy->is_player_ally() ) {
1947 update_faction_api( guy );
1948 add_npc_follower( guy->getID() );
1949 }
1950 }
1951 // Make sure that serialized player followers sync up with game list
1952 for( const auto &temp_id : u.follower_ids ) {
1953 add_npc_follower( temp_id );
1954 }
1955}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1879
static void update_faction_api(npc *guy)
Definition: game.cpp:1891

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 9966 of file game.cpp.

9967{
9968 if( u.is_mounted() ) {
9969 auto mons = u.mounted_creature.get();
9970 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
9971 if( !mons->check_mech_powered() ) {
9972 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
9973 mons->get_name() );
9974 return;
9975 }
9976 }
9977 }
9978
9979 // > and < are used for diving underwater.
9980 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
9981 if( movez == -1 ) {
9982 if( u.is_underwater() ) {
9983 add_msg( m_info, _( "You are already underwater!" ) );
9984 return;
9985 }
9986 if( u.worn_with_flag( "FLOTATION" ) ) {
9987 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
9988 return;
9989 }
9990 u.set_underwater( true );
9991 ///\EFFECT_STR increases breath-holding capacity while diving
9992 u.oxygen = 30 + 2 * u.str_cur;
9993 add_msg( _( "You dive underwater!" ) );
9994 } else {
9995 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
9996 u.set_underwater( false );
9997 add_msg( _( "You surface." ) );
9998 } else {
9999 add_msg( m_info, _( "You try to surface but can't!" ) );
10000 }
10001 }
10002 u.moves -= 100;
10003 return;
10004 }
10005
10006 // Force means we're going down, even if there's no staircase, etc.
10007 bool climbing = false;
10008 int move_cost = 100;
10009 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10010 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10011 // Climbing
10012 if( m.has_floor_or_support( stairs ) ) {
10013 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10014 return;
10015 }
10016
10017 std::vector<tripoint> pts;
10018 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10019 if( m.passable( pt ) &&
10020 m.has_floor_or_support( pt ) ) {
10021 pts.push_back( pt );
10022 }
10023 }
10024
10025 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10026
10027 if( cost == 0 ) {
10028 if( u.has_trait( trait_WEB_ROPE ) ) {
10029 if( pts.empty() ) {
10030 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10031 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10032 if( m.move_cost( u.pos() ) != 2 && m.move_cost( u.pos() ) != 3 ) {
10033 add_msg( m_info, _( "You can't spin a web rope there." ) );
10034 } else if( m.has_furn( u.pos() ) ) {
10035 add_msg( m_info, _( "There is already furniture at that location." ) );
10036 } else {
10037 if( query_yn( "Spin a rope and climb?" ) ) {
10038 add_msg( m_good, _( "You spin a rope of web." ) );
10039 m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10040 u.mod_moves( to_turns<int>( 2_seconds ) );
10042 vertical_move( movez, force, peeking );
10043 }
10044 }
10045 }
10046
10047 } else {
10048 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10049
10050 }
10051 return;
10052
10053 }
10054
10055 if( cost <= 0 || pts.empty() ) {
10056 add_msg( m_info,
10057 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10058 return;
10059 } else {
10060 // TODO: Make it an extended action
10061 climbing = true;
10062 move_cost = cost;
10063
10064 const std::optional<tripoint> pnt = point_selection_menu( pts );
10065 if( !pnt ) {
10066 return;
10067 }
10068 stairs = *pnt;
10069 }
10070 }
10071
10072 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10073 add_msg( m_info, _( "You can't go down here!" ) );
10074 return;
10075 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10076 add_msg( m_info, _( "You can't go up here!" ) );
10077 return;
10078 }
10079
10080 if( force ) {
10081 // Let go of a grabbed cart.
10082 u.grab( OBJECT_NONE );
10083 } else if( u.grab_point != tripoint_zero ) {
10084 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10085 return;
10086 }
10087
10088 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10089 // is called or when the map is loaded on new z-level (== false).
10090 // This caches the z-level we start the movement on (current) and the level we're want to end.
10091 const int z_before = get_levz();
10092 const int z_after = get_levz() + movez;
10093 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10094 debugmsg( "Tried to move outside allowed range of z-levels" );
10095 return;
10096 }
10097
10098 if( !u.move_effects( false ) ) {
10099 return;
10100 }
10101
10102 // Check if there are monsters are using the stairs.
10103 bool slippedpast = false;
10104 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10105 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10106 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10107 coming_to_stairs[0].name() );
10108 // Roll.
10109 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10110
10111 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10112 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10113 ///\EFFECT_STR increases chance of moving past monsters on stairs
10114
10115 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10116 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10117 if( coming_to_stairs.size() > 4 ) {
10118 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10119 dexroll /= 4;
10120 strroll /= 2;
10121 } else if( coming_to_stairs.size() > 1 ) {
10122 add_msg( m_warning, _( "There's something else behind it!" ) );
10123 dexroll /= 2;
10124 }
10125
10126 if( dexroll < 14 || strroll < 12 ) {
10128 u.moves -= 100;
10129 return;
10130 }
10131
10132 add_msg( _( "You manage to slip past!" ) );
10133 slippedpast = true;
10134 u.moves -= 100;
10135 }
10136
10137 // Shift the map up or down
10138
10139 std::unique_ptr<map> tmp_map_ptr;
10140 if( !m.has_zlevels() ) {
10141 tmp_map_ptr = std::make_unique<map>();
10142 }
10143
10144 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10145 if( m.has_zlevels() ) {
10146 // We no longer need to shift the map here! What joy
10147 } else {
10148 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10149 }
10150
10151 // Find the corresponding staircase
10152 bool rope_ladder = false;
10153 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10154 if( !force && !climbing ) {
10155 const std::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10156 if( !pnt ) {
10157 return;
10158 }
10159 stairs = *pnt;
10160 }
10161
10162 if( !force ) {
10163 monstairz = z_before;
10164 }
10165 // Save all monsters that can reach the stairs, remove them from the tracker,
10166 // then despawn the remaining monsters. Because it's a vertical shift, all
10167 // monsters are out of the bounds of the map and will despawn.
10168 shared_ptr_fast<monster> stored_mount;
10169 if( u.is_mounted() && !m.has_zlevels() ) {
10170 // Store a *copy* of the mount, so we can remove the original monster instance
10171 // from the tracker before the map shifts.
10172 // Map shifting would otherwise just despawn the mount and would later respawn it.
10173 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10175 }
10176 if( !m.has_zlevels() ) {
10177 const tripoint to = u.pos();
10178 for( monster &critter : all_monsters() ) {
10179 // if its a ladder instead of stairs - most zombies can't climb that.
10180 // unless that have a special flag to allow them to do so.
10181 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10182 critter.has_effect( effect_ridden ) ||
10183 critter.has_effect( effect_tied ) ) {
10184 continue;
10185 }
10186 int turns = critter.turns_to_reach( to.xy() );
10187 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10188 && !slippedpast ) {
10189 critter.staircount = 10 + turns;
10190 critter.on_unload();
10191 coming_to_stairs.push_back( critter );
10192 remove_zombie( critter );
10193 }
10194 }
10195 auto mons = critter_tracker->find( g->u.pos() );
10196 if( mons != nullptr ) {
10197 critter_tracker->remove( *mons );
10198 }
10199 shift_monsters( tripoint( 0, 0, movez ) );
10200 }
10201
10202 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10203 std::vector<monster *> monsters_following;
10204 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10205 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10206 [this]( const shared_ptr_fast<npc> &np ) {
10207 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10208 rl_dist( np->pos(), u.pos() ) < 2;
10209 } );
10210 }
10211
10212 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10213 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10214 for( monster &critter : all_monsters() ) {
10215 if( ladder && !critter.climbs() ) {
10216 continue;
10217 }
10218 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10219 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10220 !critter.has_effect( effect_tied ) ) ) {
10221 monsters_following.push_back( &critter );
10222 }
10223 }
10224 }
10225
10226 if( u.is_mounted() ) {
10227 monster *crit = u.mounted_creature.get();
10228 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10229 crit->use_mech_power( -1 );
10230 if( u.movement_mode_is( CMM_WALK ) ) {
10231 crit->use_mech_power( -2 );
10232 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10233 crit->use_mech_power( -1 );
10234 } else if( u.movement_mode_is( CMM_RUN ) ) {
10235 crit->use_mech_power( -3 );
10236 }
10237 }
10238 } else {
10239 u.moves -= move_cost;
10240 }
10241 for( const auto &np : npcs_to_bring ) {
10242 if( np->in_vehicle ) {
10243 m.unboard_vehicle( np->pos() );
10244 }
10245 }
10246 const tripoint old_pos = g->u.pos();
10247 point submap_shift;
10248 vertical_shift( z_after );
10249 if( !force ) {
10250 submap_shift = update_map( stairs.x, stairs.y );
10251 }
10252
10253 // if an NPC or monster is on the stiars when player ascends/descends
10254 // they may end up merged on th esame tile, do some displacement to resolve that.
10255 // if, in the weird case of it not being possible to displace;
10256 // ( how did the player even manage to approach the stairs, if so? )
10257 // then nothing terrible happens, its just weird.
10258 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10259 std::string crit_name;
10260 bool player_displace = false;
10261 std::optional<tripoint> displace = find_empty_spot_nearby( u.pos() );
10262 if( displace.has_value() ) {
10263 npc *guy = g->critter_at<npc>( u.pos(), true );
10264 if( guy ) {
10265 crit_name = guy->get_name();
10266 tripoint old_pos = guy->pos();
10267 if( !guy->is_enemy() ) {
10268 guy->move_away_from( u.pos(), true );
10269 if( old_pos != guy->pos() ) {
10270 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10271 }
10272 } else {
10273 player_displace = true;
10274 }
10275 }
10276 monster *mon = g->critter_at<monster>( u.pos(), true );
10277 // if the monster is ridden by the player or an NPC:
10278 // Dont displace them. If they are mounted by a friendly NPC,
10279 // then the NPC will already have been displaced just above.
10280 // if they are ridden by the player, we want them to coexist on same tile
10281 if( mon && !mon->mounted_player ) {
10282 crit_name = mon->get_name();
10283 if( mon->friendly == -1 ) {
10284 mon->setpos( *displace );
10285 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10286 } else {
10287 player_displace = true;
10288 }
10289 }
10290 if( player_displace ) {
10291 u.setpos( *displace );
10292 u.moves -= 20;
10293 add_msg( _( "You push past %s blocking the way." ), crit_name );
10294 }
10295 } else {
10296 debugmsg( "Failed to find a spot to displace into." );
10297 }
10298 }
10299
10300 // Now that we know the player's destination position, we can move their mount as well
10301 if( u.is_mounted() ) {
10302 if( stored_mount ) {
10303 assert( !m.has_zlevels() );
10304 stored_mount->spawn( g->u.pos() );
10305 if( critter_tracker->add( stored_mount ) ) {
10306 u.mounted_creature = stored_mount;
10307 }
10308 } else {
10309 u.mounted_creature->setpos( g->u.pos() );
10310 }
10311 }
10312
10313 if( !npcs_to_bring.empty() ) {
10314 // Would look nicer randomly scrambled
10315 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10316 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10317 [this]( const tripoint & c ) {
10318 return !is_empty( c );
10319 } ), candidates.end() );
10320
10321 for( const auto &np : npcs_to_bring ) {
10322 const auto found = std::find_if( candidates.begin(), candidates.end(),
10323 [this, np]( const tripoint & c ) {
10324 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10325 } );
10326 if( found != candidates.end() ) {
10327 // TODO: De-uglify
10328 np->setpos( *found );
10329 np->place_on_map();
10330 np->setpos( *found );
10331 candidates.erase( found );
10332 }
10333
10334 if( candidates.empty() ) {
10335 break;
10336 }
10337 }
10338
10339 reload_npcs();
10340 }
10341
10342 // This ugly check is here because of stair teleport bullshit
10343 // TODO: Remove stair teleport bullshit
10344 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10345 for( monster *m : monsters_following ) {
10346 m->set_dest( g->u.pos() );
10347 }
10348 }
10349
10350 if( rope_ladder ) {
10351 m.ter_set( u.pos(), t_rope_up );
10352 }
10353
10354 if( m.ter( stairs ) == t_manhole_cover ) {
10355 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10356 m.ter_set( stairs, t_manhole );
10357 }
10358
10359 // Wouldn't work and may do strange things
10360 if( u.is_hauling() && !m.has_zlevels() ) {
10361 add_msg( _( "You cannot haul items here." ) );
10362 u.stop_hauling();
10363 }
10364
10365 if( u.is_hauling() ) {
10366 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10367 start_hauling( adjusted_pos );
10368 }
10369
10370 m.invalidate_map_cache( g->get_levz() );
10371 // Upon force movement, traps can not be avoided.
10372 m.creature_on_trap( u, !force );
10373
10375}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:108
@ CMM_CROUCH
Definition: character.h:110
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1460
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:807
int oxygen
Definition: character.h:1564
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1698
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8919
std::string get_name() const override
Definition: character.cpp:5976
void set_underwater(bool x) override
void start_hauling(const tripoint &pos)
Definition: game.cpp:10377
std::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10412
bool use_mech_power(int amt)
Definition: monster.cpp:2401
Character * mounted_player
Definition: monster.h:457
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static std::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:9916
static const skill_id skill_melee("melee")
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:721
ter_id t_manhole
Definition: mapdata.cpp:720
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1687
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12036
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9359
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4178

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, map::furn_set(), g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), map::move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), Character::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 10599 of file game.cpp.

10600{
10601 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
10602 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
10603 return;
10604 }
10605
10606 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
10607 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
10608 z_before, z_after );
10609 return;
10610 }
10611 // Figure out where we know there are up/down connectors
10612 // Fill in all the tiles we know about (e.g. subway stations)
10613 static const int REVEAL_RADIUS = 40;
10614 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
10615 const tripoint_abs_omt cursp_before( p.xy(), z_before );
10616 const tripoint_abs_omt cursp_after( p.xy(), z_after );
10617
10618 if( !overmap_buffer.seen( cursp_before ) ) {
10619 continue;
10620 }
10621 if( overmap_buffer.has_note( cursp_after ) ) {
10622 // Already has a note -> never add an AUTO-note
10623 continue;
10624 }
10625 const oter_id &ter = overmap_buffer.ter( cursp_before );
10626 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
10627 if( z_after > z_before && ter->has_flag( known_up ) &&
10628 !ter2->has_flag( known_down ) ) {
10629 overmap_buffer.set_seen( cursp_after, true );
10630 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
10631 } else if( z_after < z_before && ter->has_flag( known_down ) &&
10632 !ter2->has_flag( known_up ) ) {
10633 overmap_buffer.set_seen( cursp_after, true );
10634 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
10635 }
10636 }
10637}
bool inbounds_z(const int z) const
Definition: map.h:1619
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 10562 of file game.cpp.

10563{
10564 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10565 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
10566 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
10567 return;
10568 }
10569
10570 // TODO: Implement dragging stuff up/down
10571 u.grab( OBJECT_NONE );
10572
10573 scent.reset();
10574
10575 u.setz( z_after );
10576 const int z_before = get_levz();
10577 if( !m.has_zlevels() ) {
10579 m.access_cache( z_before ).vehicle_list.clear();
10580 m.access_cache( z_before ).zone_vehicles.clear();
10581 m.access_cache( z_before ).map_memory_seen_cache.reset();
10582 m.set_transparency_cache_dirty( z_before );
10583 m.set_outside_cache_dirty( z_before );
10584 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
10585 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
10586 reload_npcs();
10587 } else {
10588 // Shift the map itself
10589 m.vertical_shift( z_after );
10590 }
10591
10592 m.spawn_monsters( true );
10593 // this may be required after a vertical shift if z-levels are not enabled
10594 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
10596 vertical_notes( z_before, z_after );
10597}
void setz(int z)
Definition: character.h:808
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:10599
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.cpp:200
void set_outside_cache_dirty(const int zlev)
Definition: map.cpp:221
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:7015
std::set< vehicle * > zone_vehicles
Definition: map.h:358
std::set< vehicle * > vehicle_list
Definition: map.h:357

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 8757 of file game.cpp.

8758{
8759 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
8760 if( u.get_size() > MS_MEDIUM ) {
8761 add_msg( m_warning, _( "You can't fit there." ) );
8762 return false; // character too large to fit through a tight passage
8763 }
8764 if( u.is_mounted() ) {
8765 monster *mount = u.mounted_creature.get();
8766 if( mount->get_size() > MS_MEDIUM ) {
8767 add_msg( m_warning, _( "Your mount can't fit there." ) );
8768 return false; // char's mount is too large for tight passages
8769 }
8770 }
8771 }
8772
8773 if( u.is_mounted() ) {
8774 auto mons = u.mounted_creature.get();
8775 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
8776 if( !mons->check_mech_powered() ) {
8777 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
8778 mons->get_name() );
8779 return false;
8780 }
8781 }
8782 if( !mons->move_effects( false ) ) {
8783 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
8784 return false;
8785 }
8786 }
8787 const optional_vpart_position vp_here = m.veh_at( u.pos() );
8788 const optional_vpart_position vp_there = m.veh_at( dest_loc );
8789
8790 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
8791 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
8792 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
8793
8794 const tripoint furn_pos = u.pos() + u.grab_point;
8795 const tripoint furn_dest = dest_loc + u.grab_point;
8796
8797 bool grabbed = u.get_grab_type() != OBJECT_NONE;
8798 if( grabbed ) {
8799 const tripoint dp = dest_loc - u.pos();
8800 pushing = dp == u.grab_point;
8801 pulling = dp == -u.grab_point;
8802 }
8803 if( grabbed && dest_loc.z != u.posz() ) {
8804 add_msg( m_warning, _( "You let go of the grabbed object." ) );
8805 grabbed = false;
8806 u.grab( OBJECT_NONE );
8807 }
8808
8809 // Now make sure we're actually holding something
8810 const vehicle *grabbed_vehicle = nullptr;
8811 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
8812 // We only care about shifting, because it's the only one that can change our destination
8813 if( m.has_furn( u.pos() + u.grab_point ) ) {
8814 shifting_furniture = !pushing && !pulling;
8815 } else {
8816 // We were grabbing a furniture that isn't there
8817 grabbed = false;
8818 }
8819 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
8820 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
8821 if( grabbed_vehicle == nullptr ) {
8822 // We were grabbing a vehicle that isn't there anymore
8823 grabbed = false;
8824 }
8825 } else if( grabbed ) {
8826 // We were grabbing something WEIRD, let's pretend we weren't
8827 grabbed = false;
8828 }
8829 if( u.grab_point != tripoint_zero && !grabbed ) {
8830 add_msg( m_warning, _( "Can't find grabbed object." ) );
8831 u.grab( OBJECT_NONE );
8832 }
8833
8834 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
8835 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
8836 vp_there->vehicle().handle_potential_theft( u ) ) {
8837 tripoint diff = dest_loc - u.pos();
8838 if( diff.x < 0 ) {
8839 diff.x -= 2;
8840 } else if( diff.x > 0 ) {
8841 diff.x += 2;
8842 }
8843 if( diff.y < 0 ) {
8844 diff.y -= 2;
8845 } else if( diff.y > 0 ) {
8846 diff.y += 2;
8847 }
8848 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
8849 dest_loc );
8850 }
8851 return false;
8852 }
8853 if( vp_there && !vp_there->vehicle().handle_potential_theft( u ) ) {
8854 return false;
8855 }
8856 if( u.is_mounted() && !pushing && vp_there ) {
8857 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
8858 return false;
8859 }
8860 u.set_underwater( false );
8861
8862 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
8863 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
8864 const auto dangerous_terrain_opt = get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" );
8865 const auto harmful_text = enumerate_as_string( harmful_stuff );
8866 const auto warn_msg = [&]( const char *const msg ) {
8867 add_msg( m_warning, msg, harmful_text );
8868 };
8869
8870 if( dangerous_terrain_opt == "IGNORE" ) {
8871 warn_msg( _( "Stepping into that %1$s looks risky, but you enter anyway." ) );
8872 } else if( dangerous_terrain_opt == "ALWAYS" && !prompt_dangerous_tile( dest_loc ) ) {
8873 return true;
8874 } else if( dangerous_terrain_opt == "RUNNING" &&
8875 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8876 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
8877 return true;
8878 } else if( dangerous_terrain_opt == "CROUCHING" &&
8879 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
8880 warn_msg( _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ) );
8881 return true;
8882 } else if( dangerous_terrain_opt == "NEVER" && !u.movement_mode_is( CMM_RUN ) ) {
8883 warn_msg( _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ) );
8884 return true;
8885 }
8886 }
8887 // Used to decide whether to print a 'moving is slow message
8888 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
8889
8890 int modifier = 0;
8891 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
8892 modifier = -m.furn( dest_loc ).obj().movecost;
8893 }
8894
8895 int multiplier = 1;
8896 if( u.is_on_ground() ) {
8897 multiplier *= 3;
8898 }
8899
8900 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
8901 via_ramp ) * multiplier;
8902 if( grabbed_move( dest_loc - u.pos() ) ) {
8903 return true;
8904 } else if( mcost == 0 ) {
8905 return false;
8906 }
8907 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
8908 const int previous_moves = u.moves;
8909 if( u.is_mounted() ) {
8910 auto crit = u.mounted_creature.get();
8911 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
8912 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
8913 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
8914 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
8915 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
8916 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
8917 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
8918 return false;
8919 }
8920 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
8921 const double encumb_moves = u.get_weight() / 4800.0_gram;
8922 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
8923 if( u.movement_mode_is( CMM_WALK ) ) {
8924 crit->use_mech_power( -2 );
8925 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
8926 crit->use_mech_power( -1 );
8927 } else if( u.movement_mode_is( CMM_RUN ) ) {
8928 crit->use_mech_power( -3 );
8929 }
8930 } else {
8931 u.moves -= u.run_cost( mcost, diag );
8932 /**
8933 TODO:
8934 This should really use the mounted creatures stamina, if mounted.
8935 Monsters don't currently have stamina however.
8936 For the time being just don't burn players stamina when mounted.
8937 */
8938 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
8939 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
8940 u.burn_move_stamina( previous_moves - u.moves );
8941 } else {
8942 //Burn half as much stamina if vehicle has wheels, without changing move time
8943 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
8944 }
8945 }
8946 // Max out recoil & reset aim point
8948 u.last_target_pos = std::nullopt;
8949
8950 // Print a message if movement is slow
8951 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
8952 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
8953 m.has_flag_ter_or_furn( "FUNGUS",
8954 dest_loc ); //fungal furniture has no slowing effect on mycus characters
8955 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
8956 mcost_to > 4 || mcost_from > 4 ) &&
8957 !( u.has_trait( trait_M_IMMUNE ) && fungus );
8958 if( slowed && !u.is_mounted() ) {
8959 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
8960 if( mcost_to >= mcost_from ) {
8961 if( auto displayed_part = vp_there.part_displayed() ) {
8962 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
8963 displayed_part->part().name() );
8964 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
8965 } else {
8966 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
8967 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
8968 }
8969 } else {
8970 if( auto displayed_part = vp_here.part_displayed() ) {
8971 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
8972 displayed_part->part().name() );
8973 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
8974 } else {
8975 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
8976 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
8977 }
8978 }
8979 }
8980 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
8981 ( !u.footwear_factor() ||
8982 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
8983 // DX and IN are long suits for Cephalopods,
8984 // so this shouldn't cause too much hardship
8985 // Presumed that if it's swimmable, they're
8986 // swimming and won't stick
8987 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
8988
8989 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
8990 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
8991 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
8992 u.mod_fatigue( 1 );
8993 }
8994 }
8995 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
8996 int volume = u.is_stealthy() ? 3 : 6;
8997 volume *= u.mutation_value( "noise_modifier" );
8998 if( volume > 0 ) {
9000 volume = 2;
9001 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9002 volume = 12;
9003 }
9004 if( u.movement_mode_is( CMM_RUN ) ) {
9005 volume *= 1.5;
9006 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9007 volume /= 2;
9008 }
9009 if( u.is_mounted() ) {
9010 auto mons = u.mounted_creature.get();
9011 switch( mons->get_size() ) {
9012 case MS_TINY:
9013 volume = 0; // No sound for the tinies
9014 break;
9015 case MS_SMALL:
9016 volume /= 3;
9017 break;
9018 case MS_MEDIUM:
9019 break;
9020 case MS_LARGE:
9021 volume *= 1.5;
9022 break;
9023 case MS_HUGE:
9024 volume *= 2;
9025 break;
9026 default:
9027 break;
9028 }
9029 if( mons->has_flag( MF_LOUDMOVES ) ) {
9030 volume += 6;
9031 }
9032 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9033 "none", "none" );
9034 } else {
9035 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9036 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9037 }
9039 }
9040
9041 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9042 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9043 "misc", "rattling" );
9044 }
9045 }
9046
9047 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9048 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9049 }
9050
9051 if( dest_loc != u.pos() ) {
9053 }
9054
9055 tripoint oldpos = u.pos();
9056 point submap_shift = place_player( dest_loc );
9057 point ms_shift = sm_to_ms_copy( submap_shift );
9058 oldpos = oldpos - ms_shift;
9059
9060 if( pulling ) {
9061 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9062 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9063 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9064 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9065 m.remove_field( shifted_furn_pos, fd_fire );
9066 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9067 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9068 }
9069
9070 if( u.is_hauling() ) {
9071 start_hauling( oldpos );
9072 }
9073
9075
9076 return true;
9077}
void burn_move_stamina(int moves)
Definition: character.cpp:7095
bool is_stealthy() const
Returns true if the player has stealthy movement.
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3195
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3669
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:887
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6621
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
Definition: character.cpp:9995
m_size get_size() const override
Get size class of character.
Definition: character.cpp:565
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:9683
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:8686
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1897
m_size get_size() const override
Definition: monster.cpp:2695
std::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2499
std::optional< tripoint > last_target_pos
Definition: player.h:242
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2222
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1633
void do_footstep()
Definition: sounds.cpp:1610

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), Character::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), Character::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2434 of file game.cpp.

2435{
2436 win_screen();
2438 memorial().add(
2439 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2440 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2441 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2442 if( !u.is_dead_state() ) {
2445 }
2446}
void win_screen()
Definition: game.cpp:2448
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), Character::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2448 of file game.cpp.

2449{
2450 // TODO: Move this wall somewhere
2452 std::string msg = _( "You managed to close the portal and end the invasion!" );
2453 msg += '\n';
2454 if( u.is_dead_state() ) {
2456 "Unfortunately, you had to sacrifice your life to achieve this." );
2457 msg += colorize( t, c_red ) + '\n';
2458 memorial().add(
2459 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2460 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2461 } else {
2462 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2463 msg += colorize( t, c_green ) + '\n';
2464 memorial().add(
2465 pgettext( "memorial_male", "Safely closed the portal." ),
2466 pgettext( "memorial_female", "Safely closed the portal." ) );
2467 }
2468 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2469 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2470 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2471 popup( msg );
2472}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.

References _, memorial_logger::add(), c_green, c_red, colorize(), Character::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 2772 of file game.cpp.

2773{
2774 const std::string &memorial_dir = PATH_INFO::memorialdir();
2775 const std::string &memorial_active_world_dir = memorial_dir +
2776 world_generator->active_world->world_name + "/";
2777
2778 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
2779 if( !assure_dir_exist( memorial_dir ) ) {
2780 debugmsg( "Could not make '%s' directory", memorial_dir );
2781 return;
2782 }
2783
2784 if( !assure_dir_exist( memorial_active_world_dir ) ) {
2785 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
2786 return;
2787 }
2788
2789 std::string path = memorial_active_world_dir + filename + ".txt";
2790
2791 write_to_file( path, [&]( std::ostream & fout ) {
2792 memorial().write( fout, sLastWords );
2793 }, _( "player memorial" ) );
2794}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:222

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6092 of file game.cpp.

6093{
6094 const tripoint stored_view_offset = u.view_offset;
6095
6097
6098 const int zone_ui_height = 12;
6099 const int zone_options_height = 7;
6100
6101 const int width = 45;
6102
6103 int offsetX = 0;
6104 int max_rows = 0;
6105
6106 catacurses::window w_zones;
6107 catacurses::window w_zones_border;
6108 catacurses::window w_zones_info;
6109 catacurses::window w_zones_info_border;
6110 catacurses::window w_zones_options;
6111
6112 bool show = true;
6113
6114 ui_adaptor ui;
6115 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6116 if( !show ) {
6117 ui.position( point_zero, point_zero );
6118 return;
6119 }
6120 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6121 TERMX - width : 0;
6122 const int w_zone_height = TERMY - zone_ui_height;
6123 max_rows = w_zone_height - 2;
6124 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6125 point( offsetX + 1, 1 ) );
6126 w_zones_border = catacurses::newwin( w_zone_height, width,
6127 point( offsetX, 0 ) );
6128 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6129 width - 2, point( offsetX + 1, w_zone_height ) );
6130 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6131 point( offsetX, w_zone_height ) );
6132 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6133 point( offsetX + 1, TERMY - zone_options_height ) );
6134
6135 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6136 } );
6137 ui.mark_resize();
6138
6139 std::string action;
6140 input_context ctxt( "ZONES_MANAGER" );
6141 ctxt.register_cardinal();
6142 ctxt.register_action( "CONFIRM" );
6143 ctxt.register_action( "QUIT" );
6144 ctxt.register_action( "ADD_ZONE" );
6145 ctxt.register_action( "REMOVE_ZONE" );
6146 ctxt.register_action( "MOVE_ZONE_UP" );
6147 ctxt.register_action( "MOVE_ZONE_DOWN" );
6148 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6149 ctxt.register_action( "ENABLE_ZONE" );
6150 ctxt.register_action( "DISABLE_ZONE" );
6151 ctxt.register_action( "SHOW_ALL_ZONES" );
6152 ctxt.register_action( "HELP_KEYBINDINGS" );
6153
6154 auto &mgr = zone_manager::get_manager();
6155 int start_index = 0;
6156 int active_index = 0;
6157 bool blink = false;
6158 bool stuff_changed = false;
6159 bool show_all_zones = false;
6160 int zone_cnt = 0;
6161
6162 // get zones on the same z-level, with distance between player and
6163 // zone center point <= 50 or all zones, if show_all_zones is true
6164 auto get_zones = [&]() {
6165 std::vector<zone_manager::ref_zone_data> zones;
6166 if( show_all_zones ) {
6167 zones = mgr.get_zones();
6168 } else {
6169 const tripoint &u_abs_pos = m.getabs( u.pos() );
6170 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6171 const tripoint &zone_abs_pos = ref.get().get_center_point();
6172 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6173 zones.emplace_back( ref );
6174 }
6175 }
6176 }
6177 zone_cnt = static_cast<int>( zones.size() );
6178 return zones;
6179 };
6180
6181 auto zones = get_zones();
6182
6183 auto zones_manager_options = [&]() {
6184 werase( w_zones_options );
6185
6186 if( zone_cnt > 0 ) {
6187 const auto &zone = zones[active_index].get();
6188
6189 if( zone.has_options() ) {
6190 const auto &descriptions = zone.get_options().get_descriptions();
6191
6192 // NOLINTNEXTLINE(cata-use-named-point-constants)
6193 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6194
6195 int y = 1;
6196 for( const auto &desc : descriptions ) {
6197 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6198 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6199 y++;
6200 }
6201 }
6202 }
6203
6204 wnoutrefresh( w_zones_options );
6205 };
6206
6207 std::optional<tripoint> zone_start;
6208 std::optional<tripoint> zone_end;
6209 bool zone_blink = false;
6210 bool zone_cursor = false;
6212 zone_start, zone_end, zone_blink, zone_cursor );
6213 add_draw_callback( zone_cb );
6214
6215 auto query_position =
6216 [&]() -> std::optional<std::pair<tripoint, tripoint>> {
6217 on_out_of_scope invalidate_current_ui( [&]()
6218 {
6219 ui.mark_resize();
6220 } );
6221 restore_on_out_of_scope<bool> show_prev( show );
6222 restore_on_out_of_scope<std::optional<tripoint>> zone_start_prev( zone_start );
6223 restore_on_out_of_scope<std::optional<tripoint>> zone_end_prev( zone_end );
6224 show = false;
6225 zone_start = std::nullopt;
6226 zone_end = std::nullopt;
6227 ui.mark_resize();
6228
6230 popup.on_top( true );
6231 popup.message( "%s", _( "Select first point." ) );
6232
6234
6235 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6236 false );
6237 if( first.position )
6238 {
6239 popup.message( "%s", _( "Select second point." ) );
6240
6241 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6242 true, true, false );
6243 if( second.position ) {
6244 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6245 second.position->x ),
6246 std::min( first.position->y, second.position->y ),
6247 std::min( first.position->z,
6248 second.position->z ) ) );
6249 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6250 second.position->x ),
6251 std::max( first.position->y, second.position->y ),
6252 std::max( first.position->z,
6253 second.position->z ) ) );
6254 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6255 }
6256 }
6257
6258 return std::nullopt;
6259 };
6260
6261 ui.on_redraw( [&]( const ui_adaptor & ) {
6262 if( !show ) {
6263 return;
6264 }
6265 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6266 zones_manager_shortcuts( w_zones_info );
6267
6268 if( zone_cnt == 0 ) {
6269 werase( w_zones );
6270 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6271
6272 } else {
6273 werase( w_zones );
6274
6275 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6276
6277 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6278 wnoutrefresh( w_zones_border );
6279
6280 int iNum = 0;
6281
6282 tripoint player_absolute_pos = m.getabs( u.pos() );
6283
6284 //Display saved zones
6285 for( auto &i : zones ) {
6286 if( iNum >= start_index &&
6287 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6288 const auto &zone = i.get();
6289
6290 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6291
6292 if( iNum == active_index ) {
6293 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6294 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6295 }
6296
6297 //Draw Zone name
6298 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6299 trim_by_length( zone.get_name(), 15 ) );
6300
6301 //Draw Type name
6302 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6303 mgr.get_name_from_type( zone.get_type() ) );
6304
6305 tripoint center = zone.get_center_point();
6306
6307 //Draw direction + distance
6308 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6309 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6310 direction_name_short( direction_from( player_absolute_pos,
6311 center ) ) );
6312
6313 //Draw Vehicle Indicator
6314 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6315 zone.get_is_vehicle() ? "*" : "" );
6316 }
6317 iNum++;
6318 }
6319
6320 // Display zone options
6321 zones_manager_options();
6322 }
6323
6324 wnoutrefresh( w_zones );
6325 } );
6326
6327 zones_manager_open = true;
6328 do {
6329 if( action == "ADD_ZONE" ) {
6330 do { // not a loop, just for quick bailing out if canceled
6331 const auto maybe_id = mgr.query_type();
6332 if( !maybe_id.has_value() ) {
6333 break;
6334 }
6335
6336 const zone_type_id &id = maybe_id.value();
6337 auto options = zone_options::create( id );
6338
6339 if( !options->query_at_creation() ) {
6340 break;
6341 }
6342
6343 auto default_name = options->get_zone_name_suggestion();
6344 if( default_name.empty() ) {
6345 default_name = mgr.get_name_from_type( id );
6346 }
6347 const auto maybe_name = mgr.query_name( default_name );
6348 if( !maybe_name.has_value() ) {
6349 break;
6350 }
6351 const std::string &name = maybe_name.value();
6352
6353 const auto position = query_position();
6354 if( !position ) {
6355 break;
6356 }
6357
6358 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6359 position->second, options );
6360
6361 zones = get_zones();
6362 active_index = zone_cnt - 1;
6363
6364 stuff_changed = true;
6365 } while( false );
6366
6367 blink = false;
6368 } else if( action == "SHOW_ALL_ZONES" ) {
6369 show_all_zones = !show_all_zones;
6370 zones = get_zones();
6371 active_index = 0;
6372 } else if( zone_cnt > 0 ) {
6373 if( action == "UP" ) {
6374 active_index--;
6375 if( active_index < 0 ) {
6376 active_index = zone_cnt - 1;
6377 }
6378 blink = false;
6379 } else if( action == "DOWN" ) {
6380 active_index++;
6381 if( active_index >= zone_cnt ) {
6382 active_index = 0;
6383 }
6384 blink = false;
6385 } else if( action == "REMOVE_ZONE" ) {
6386 if( active_index < zone_cnt ) {
6387 mgr.remove( zones[active_index] );
6388 zones = get_zones();
6389 active_index--;
6390
6391 if( active_index < 0 ) {
6392 active_index = 0;
6393 }
6394 }
6395 blink = false;
6396 stuff_changed = true;
6397
6398 } else if( action == "CONFIRM" ) {
6399 auto &zone = zones[active_index].get();
6400
6401 uilist as_m;
6402 as_m.text = _( "What do you want to change:" );
6403 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6404 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6405 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6406 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6407 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6408 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6409 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6410 as_m.query();
6411
6412 switch( as_m.ret ) {
6413 case 1:
6414 if( zone.set_name() ) {
6415 stuff_changed = true;
6416 }
6417 break;
6418 case 2:
6419 if( zone.set_type() ) {
6420 stuff_changed = true;
6421 }
6422 break;
6423 case 3:
6424 if( zone.get_options().query() ) {
6425 stuff_changed = true;
6426 }
6427 break;
6428 case 4: {
6429 const auto pos = query_position();
6430 if( pos && ( pos->first != zone.get_start_point() ||
6431 pos->second != zone.get_end_point() ) ) {
6432 zone.set_position( *pos );
6433 stuff_changed = true;
6434 }
6435 break;
6436 }
6437 case 5: {
6438 on_out_of_scope invalidate_current_ui( [&]() {
6439 ui.mark_resize();
6440 } );
6441 restore_on_out_of_scope<bool> show_prev( show );
6442 restore_on_out_of_scope<std::optional<tripoint>> zone_start_prev( zone_start );
6443 restore_on_out_of_scope<std::optional<tripoint>> zone_end_prev( zone_end );
6444 show = false;
6445 zone_start = std::nullopt;
6446 zone_end = std::nullopt;
6447 ui.mark_resize();
6448 static_popup message_pop;
6449 message_pop.on_top( true );
6450 message_pop.message( "%s", _( "Moving zone." ) );
6451 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6452 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6453 // local position of the zone center, used to calculate the u.view_offset,
6454 // could center the screen to the position it represents
6455 auto view_center = m.getlocal( zone.get_center_point() );
6456 const look_around_result result_local = look_around( false, view_center,
6457 zone_local_start_point, false, false,
6458 false, true, zone_local_end_point );
6459 if( result_local.position ) {
6460 const auto new_start_point = m.getabs( *result_local.position );
6461 if( new_start_point == zone.get_start_point() ) {
6462 break; // Nothing changed, don't save
6463 }
6464
6465 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6466 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6467 stuff_changed = true;
6468 }
6469 }
6470 break;
6471 default:
6472 break;
6473 }
6474
6475 blink = false;
6476 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6477 if( active_index < zone_cnt - 1 ) {
6478 mgr.swap( zones[active_index], zones[active_index + 1] );
6479 zones = get_zones();
6480 active_index++;
6481 }
6482 blink = false;
6483 stuff_changed = true;
6484
6485 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6486 if( active_index > 0 ) {
6487 mgr.swap( zones[active_index], zones[active_index - 1] );
6488 zones = get_zones();
6489 active_index--;
6490 }
6491 blink = false;
6492 stuff_changed = true;
6493
6494 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6495 //show zone position on overmap;
6496 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6497 // TODO: fix point types
6498 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6499
6500 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6501 } else if( action == "ENABLE_ZONE" ) {
6502 zones[active_index].get().set_enabled( true );
6503
6504 stuff_changed = true;
6505
6506 } else if( action == "DISABLE_ZONE" ) {
6507 zones[active_index].get().set_enabled( false );
6508
6509 stuff_changed = true;
6510 }
6511 }
6512
6513 if( zone_cnt > 0 ) {
6514 blink = !blink;
6515 const auto &zone = zones[active_index].get();
6516 zone_start = m.getlocal( zone.get_start_point() );
6517 zone_end = m.getlocal( zone.get_end_point() );
6518 ctxt.set_timeout( get_option<int>( "BLINK_SPEED" ) );
6519 } else {
6520 blink = false;
6521 zone_start = zone_end = std::nullopt;
6522 ctxt.reset_timeout();
6523 }
6524
6525 // Actually accessed from the terrain overlay callback `zone_cb` in the
6526 // call to `ui_manager::redraw`.
6527 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6528 zone_blink = blink;
6530
6532
6533 //Wait for input
6534 action = ctxt.handle_input();
6535 } while( action != "QUIT" );
6536 zones_manager_open = false;
6537 ctxt.reset_timeout();
6538 zone_cb = nullptr;
6539
6540 if( stuff_changed ) {
6541 auto &zones = zone_manager::get_manager();
6542 if( query_yn( _( "Save changes?" ) ) ) {
6543 zones.save_zones();
6544 } else {
6545 zones.load_zones();
6546 }
6547
6548 zones.cache_data();
6549 }
6550
6551 u.view_offset = stored_view_offset;
6552}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:342
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:186
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6027
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6050
void optional(const JsonObject &jo, const bool was_loaded, const std::string &name, MemberType &member)
std::string options()
Definition: path_info.cpp:230
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
std::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), query_popup::on_top(), optional(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7054 of file game.cpp.

7055{
7056#if defined(TILES)
7057 if( tileset_zoom == 64 ) {
7058 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7059 } else {
7061 }
7062 rescale_tileset( tileset_zoom );
7063#endif
7064}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7042 of file game.cpp.

7043{
7044#if defined(TILES)
7045 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7047 } else {
7048 tileset_zoom = 64;
7049 }
7050 rescale_tileset( tileset_zoom );
7051#endif
7052}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 334 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 104 of file avatar.cpp.

105{
106 return g->u;
107}

Referenced by butcher_submenu(), and get_player_base_save_path().

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12052 of file game.cpp.

12053{
12054 return *g->grid_tracker_ptr;
12055}

◆ get_map

map & get_map ( )
friend

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 393 of file character.cpp.

394{
395 return g->u;
396}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 333 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 954 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1017 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1034 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1048 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 998 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 999 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1011 of file game.h.

◆ displaying_overlays

std::optional<action_id> game::displaying_overlays
private

Definition at line 918 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1009 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 225 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 996 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 952 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1050 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 958 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 224 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 955 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1067 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1069 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1068 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1040 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1041 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1031 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1030 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 949 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 948 of file game.h.

◆ m

map& game::m

Definition at line 962 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), chat(), check_near_zone(), check_zone(), control_vehicle(), delete_cyborg_item(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 946 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 956 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 983 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1039 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 979 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1037 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1035 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1046 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1018 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1044 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1043 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1014 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1033 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen = nullptr

Definition at line 981 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 964 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 950 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1062 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1029 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1013 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 957 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 953 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 985 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1059 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 951 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 965 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 974 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1020 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 963 of file game.h.

Referenced by add_artifact_dreams(), add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), death_screen(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), toggle_gate(), try_get_left_click_action(), try_get_right_click_action(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 947 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1024 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 977 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1056 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 989 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1027 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 988 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 987 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1026 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1075 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1016 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 959 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1052 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: